Upload folder using huggingface_hub

.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

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Control de Versiones con Git y GitHub De Básico a Avanzado.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96293b8903f7e83b9015781e1a669dbdde2c337916df612f308a40cafa911752
+size 75495300

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Control de Versiones con Git y GitHub De Básico 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á.
+

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/

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Fundamentos de Git Configuración y Comandos Básicos.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db99c2af8f27a0557b67bc31115be9378eecec317ca8b84042caf61a674bcb46
+size 44475479

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Fundamentos de Git Configuración y Comandos Básicos.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.

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/

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Control de Versiones con Git Comandos Básicos y Flujo de Trabajo.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca86e2dbcb7be0d2208149b38168161c444629e6229b92642861f7ca667ec37d
+size 69225670

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Control de Versiones con Git Comandos Básicos 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.

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

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Gestión de ramas en Git creación fusión y eliminación eficiente.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70462a3975de4de1ace23cd999288b6c08785919bba3fba03424496e841247c7
+size 51098214

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Gestión de ramas en Git creación fusión y eliminación 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.
+

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

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Git Reset vs Git Revert Manejo de Historial y Corrección de Errores.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:525e41977ac6e934fa36bd72651f42dd612b5b85f77c372f51204ecf394389b4
+size 112515730

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Git Reset vs Git Revert Manejo de Historial y Corrección 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.

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

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

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Uso de Git Tag y Git Checkout para Gestión de Versiones y Revisión.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43fed4ca3944c310db088746e29c8d65296e5c9939d9564b7d113ec3f433a9fa
+size 88278422

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Uso de Git Tag y Git Checkout para Gestión de Versiones y Revisión.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.
+

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

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resolución 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

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resolución 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.
+

Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://code.visualstudio.com/

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

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.
+

Curso de Git y GitHub/02-Introducción a GitHub/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com

Curso de Git y GitHub/02-Introducción a GitHub/01-Uso de GitHub para Colaboración y Desarrollo Seguro.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c8307d268509a8ab976f2a4202cd7b24b54783e41aacd59043b9bf8f2976ae0
+size 94277565

Curso de Git y GitHub/02-Introducción a GitHub/01-Uso de GitHub para Colaboración 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.
+

Curso de Git y GitHub/02-Introducción a GitHub/02-Creación y configuración de cuenta GitHub paso a paso.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bba73de0980773ecd6063db440eac10c50ad3dfac0f8a06e60cf9dc65d22bf1
+size 88687443

Curso de Git y GitHub/02-Introducción a GitHub/02-Creación y configuración 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á.

Curso de Git y GitHub/02-Introducción a GitHub/02-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/

Curso de Git y GitHub/02-Introducción a GitHub/03-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://docs.github.com/es/get-started/start-your-journey

Curso de Git y GitHub/02-Introducción a GitHub/03-Proceso de Trabajo con Git y GitHub Creación y Revisión de Repositorios.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b403a303a9297ec6b044736c06f46114fdc7260c37f7c0829d4cb6a5a0d900f7
+size 52665705

Curso de Git y GitHub/02-Introducción a GitHub/03-Proceso de Trabajo con Git y GitHub Creación y Revisión 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.
+

Curso de Git y GitHub/02-Introducción a GitHub/04-Creación y colaboración en repositorios de GitHub.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28e40f081ee750813e4f4e27526dca242b777e1fd997e4aeb49e5cad9987aa39
+size 37776813

Curso de Git y GitHub/02-Introducción a GitHub/04-Creación y colaboración 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.

Curso de Git y GitHub/02-Introducción a GitHub/04-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/git-github