Introducci贸n a Git

1

驴Por qu茅 usar un sistema de control de versiones como Git?

2

驴Qu茅 es Git?

3

Instalando GitBash en Windows

4

Instalando Git en OSX

5

Instalando Git en Linux

6

Editores de c贸digo, archivos binarios y de texto plano

7

Introducci贸n a la terminal y l铆nea de comandos

Comandos b谩sicos en Git

8

Crea un repositorio de Git y haz tu primer commit

9

Analizar cambios en los archivos de tu proyecto con Git

10

驴Qu茅 es el staging?

11

驴Qu茅 es branch (rama) y c贸mo funciona un Merge en Git?

12

Volver en el tiempo en nuestro repositorio utilizando reset y checkout

13

Git reset vs. Git rm

Flujo de trabajo b谩sico en Git

14

Flujo de trabajo b谩sico con un repositorio remoto

15

Introducci贸n a las ramas o branches de Git

16

Fusi贸n de ramas con Git merge

17

Resoluci贸n de conflictos al hacer un merge

Trabajando con repositorios remotos en GitHub

18

C贸mo funcionan las llaves p煤blicas y privadas

19

Configura tus llaves SSH en local

20

Uso de GitHub

21

Cambios en GitHub: de master a main

22

Tu primer push

23

Git tag y versiones en Github

24

Manejo de ramas en GitHub

25

Configurar m煤ltiples colaboradores en un repositorio de GitHub

Flujos de trabajo profesionales

26

Flujo de trabajo profesional: Haciendo merge de ramas de desarrollo a master

27

Flujo de trabajo profesional con Pull requests

28

Utilizando Pull Requests en GitHub

29

Creando un Fork, contribuyendo a un repositorio

30

Haciendo deployment a un servidor

31

Hazme un pull request

32

Ignorar archivos en el repositorio con .gitignore

33

Readme.md es una excelente pr谩ctica

34

Tu sitio web p煤blico con GitHub Pages

Multiples entornos de trabajo en Git

35

Git Rebase: reorganizando el trabajo realizado

36

C贸mo usar Git Stash: guarda cambios temporalmente

37

Git Clean: limpiar tu proyecto de archivos no deseados

38

Git cherry-pick: traer commits antiguos al head del branch

Comandos de Git para casos de emergencia

39

Git Reset y Reflog: 煤sese en caso de emergencia

40

Reconstruir commits en Git con amend

41

Buscar en archivos y commits de Git con Grep y log

Bonus sobre Git y Github

42

Comandos y recursos colaborativos en Git y GitHub

43

Tu futuro con Git y GitHub

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Creando un Fork, contribuyendo a un repositorio

29/43
Recursos

Los forks o bifurcaciones son una caracter铆stica 煤nica de GitHub en la que se crea una copia exacta del estado actual de un repositorio directamente en GitHub. Este repositorio podr谩 servir como otro origen y se podr谩 clonar (como cualquier otro repositorio). En pocas palabras, lo podremos utilizar como un nuevo repositorio git cualquiera

Un fork es como una bifurcaci贸n del repositorio completo. Comparte una historia en com煤n con el original, pero de repente se bifurca y pueden aparecer varios cambios, ya que ambos proyectos podr谩n ser modificados en paralelo y para estar al d铆a un colaborador tendr谩 que estar actualizando su fork con la informaci贸n del original.

Al hacer un fork de un poryecto en GitHub, te conviertes en due帽@ del repositorio fork, puedes trabajar en este con todos los permisos, pero es un repositorio completamente diferente que el original, teniendo solamente alguna historia en com煤n (como cr茅dito al creado o creadora original).

Los forks son importantes porque es la manera en la que funciona el open source, ya que, una persona puede no ser colaborador de un proyecto, pero puede contribu铆r al mismo, haciendo mejor software que pueda ser utilizado por cualquiera.

C贸mo se hace un fork remoto desde consola en GitHub

Al hacer un fork, GitHub sabe que se hizo el fork del proyecto, por lo que se le permite al colaborador hacer pull request desde su repositorio propio.

Cuando trabajas en un proyecto que existe en diferentes repositorios remotos (normalmente a causa de un fork), es muy probable que desees poder trabajar con ambos repositorios. Para esto, puedes generar un remoto adicional desde consola.

git remote add <nombre_del_remoto> <url_del_remoto> 
git remote upstream https://github.com/freddier/hyperblog

Al crear un remoto adicional, podremos hacer pull desde el nuevo origen. En caso de tener permisos, podremos hacer fetch y push.

git pull <remoto> <rama>
git pull upstream master

Este pull nos traer谩 los cambios del remoto, por lo que se estar谩 al d铆a en el proyecto. El flujo de trabajo cambia, en adelante se estar谩 trabajando haciendo pull desde el upstream y push al origin para pasar a hacer pull request.

git pull upstream master
git push origin master

Aporte creado por: David Behar

Aportes 458

Preguntas 122

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Forks o Bifurcaciones

Es una caracter铆stica 煤nica de GitHub en la que se crea una copia exacta del estado actual de un repositorio directamente en GitHub, 茅ste repositorio podr谩 servir como otro origen y se podr谩 clonar (como cualquier otro repositorio), en pocas palabras, lo podremos utilizar como un git cualquiera
.
Un fork es como una bifurcaci贸n del repositorio completo, tiene una historia en com煤n, pero de repente se bifurca y pueden variar los cambios, ya que ambos proyectos podr谩n ser modificados en paralelo y para estar al d铆a un colaborador tendr谩 que estar actualizando su fork con la informaci贸n del original.
.
Al hacer un fork de un poryecto en GitHub, te conviertes en due帽@ del repositorio fork, puedes trabajar en 茅ste con todos los permisos, pero es un repositorio completamente diferente que el original, teniendo alguna historia en com煤n.
.
Los forks son importantes porque es la manera en la que funciona el open source, ya que, una persona puede no ser colaborador de un proyecto, pero puede contribu铆r al mismo, haciendo mejor software que pueda ser utilizado por cualquiera.
.
Al hacer un fork, GitHub sabe que se hizo el fork del proyecto, por lo que se le permite al colaborador hacer pull request desde su repositorio propio.

Trabajando con m谩s de 1 repositorio remoto

Cuando trabajas en un proyecto que existe en diferentes repositorios remotos (normalmente a causa de un fork) es muy probable que desees poder trabajar con ambos repositorios, para 茅sto puedes crear un remoto adicional desde consola.

git remote add <nombre_del_remoto> <url_del_remoto> 
git remote upstream https://github.com/freddier/hyperblog

Al crear un remoto adicional podremos, hacer pull desde el nuevo origen (en caso de tener permisos podremos hacer fetch y push)

git pull <remoto> <rama>
git pull upstream master

脡ste pull nos traer谩 los cambios del remoto, por lo que se estar谩 al d铆a en el proyecto, el flujo de trabajo cambia, en adelante se estar谩 trabajando haciendo pull desde el upstream y push al origin para pasar a hacer pull request.

git pull upstream master
git push origin master

**Apuntes! **鉁岎煆

Pobre anita! paso de trabajar por un sueldo a ser despedida para trabajar como una colaboradora鈥
Se帽or Freddy

P.D: Excelente clase!

Solo para resaltar algo de este video, despues de hacer el clone podemos tratar de consultar las ramas que se descargaron al repositorio local con 鈥済it branch鈥 y nos damos cuenta que solo aparece la rama master. pero y entonces鈥 驴que pas贸 con las otras ramas?

Soluci贸n: Si hacemos un 鈥済it branch --all鈥 vamos a ver todas las ramas tanto locales como remotas y basta con cambiar de rama, por ejemplo con: 鈥済it checkout cabecera鈥 y automaticamente se crea una copia de esta rama en el repositorio local.

Para confirmarlo haces nuevamente un 鈥済it branch鈥 y veran que ahora si aparacen la rama master y la rama cabecera.

Adi贸s Anita, siempre te recordaremos鈥

Pero que gran explicaci贸n!!!
.
Para subir cambios al repositorio original:
.

  1. Ubicar el repositorio del proyecto open source con el cual quiero colaborar.
    • Watch 鈫 Watching
    • Star
    • Fork: Tomar una copia del estado actual del proyecto y clonarlo, y queda como un proyecto mio.
  2. Clonamos el repositorio en nuestro local.
  3. Realizamos los cambios necesarios.
  4. New Pull Request.

.

Para traer cambios del repositorio original:
.

  1. Crear una nueva fuente para traer esos cambios:

    git remote -v
    git remote add upstream [original_repository_url]
    git remote -v
    git pull upstream master

  2. Actualizar nuestro repositorio en Github

    git push origin master

*******************
****Iniciar Git****
*******************

git int

*******************
****Iniciar Git****
*******************

**********************************
*******Configuraci贸n de Git*******
**********************************

git config
git config --list
git config --list --show origin
git config --list --show-origin
git config --global
git config --global user.name "SC"
git config --global user.email "[email protected]"

**********************************
*******Configuraci贸n de Git*******
**********************************

********************************************
******Agragar a la zona de preparaci贸n******
********************************************

git add Archivo.txt

git add .

********************************************
******Agragar a la zona de preparaci贸n******
********************************************

****************************
*********Ver estado*********
****************************

git status

****************************
*********Ver estado*********
****************************

***************************************************************************
*****************Quitar de la zona de preparaci贸n**************************
***************************************************************************

git rm --cached archivo.txt (Quitar de la zona de preparaci贸n).

***************************************************************************
*****************Quitar de la zona de preparaci贸n**************************
***************************************************************************

************************************************************
**********************Realizar commint**********************
************************************************************

git commit -m "Este es el pimer commit de este archivo"
git commit -am "Este es el pimer commit de este archivo"

************************************************************
**********************Realizar commint**********************
************************************************************

*****************************************************
*******Ver el historial de cambios del archivo*******
*****************************************************

git log
git log Archivo.txt

*****************************************************
*******Ver el historial de cambios del archivo*******
*****************************************************

***************************************************************
************Muestra todos los cambios sobre un archivo*********
***************************************************************

git show Archivo.txt

***************************************************************
************Muestra todos los cambios sobre un archivo*********
***************************************************************

**************************************
**********Comparar versiones**********
**************************************

git diff commint commint

**************************************
**********Comparar versiones**********
**************************************

*****************************************************************************
************************Volver a una versi贸n anterior************************
*****************************************************************************

git reset commit --hard (borramos todos los cambios y lo que tengamos en staging) 

git reset commit --soft (soft conservamos cambios y lo que tengamos en staging) 

git checkout (commit) Archivo.txt

git checkout (rama) Archivo.txt
*****************************************************************************
************************Volver a una versi贸n anterior************************
*****************************************************************************

****************************************************************************
**************************Ver Cambio en bytes*******************************
****************************************************************************

git log --stat(Cambio en bytes)

****************************************************************************
**************************Ver Cambio en bytes*******************************
****************************************************************************

***************************************************************************
****************************Crear una rama*********************************
***************************************************************************

git branch (branchName)

***************************************************************************
****************************Crear una rama*********************************
***************************************************************************


***************************************************************************
**************************Cambiar de rama**********************************
***************************************************************************

git checkout (branchName)

***************************************************************************
**************************Cambiar de rama**********************************
***************************************************************************

*******************************************************************
************************Merge entre branchs************************
*******************************************************************

git merge (branchName)

**Estar en la rama master o en la que se quiere dejar el <Head>**
*******************************************************************
************************Merge entre branchs************************
*******************************************************************

****************************************************
************Traer un repositorio externo************
****************************************************

git remote add origin (url)
git remote (muestra el origen)
git remote -v(es verval)

git pull origin master --allow-unrelated-histories (Fuerza la union de las diferentes historias)

git pull origin master (Descarga cambios)

git push (origin) (master) (Sube Cambios)
****************************************************
************Traer un repositorio externo************
****************************************************

*************************************
**************Seguridad**************
*************************************

ssh-keygen -t rsa -b 4096 -C "[email protected]" (crea la llave publica y privada)
eval $(ssh-agent -s) (saber si el agente ssh esta ejecuntando)
ssh-add ~/.ssh/id_rsa (agregar la llave privada)

git remote set-url origin git@github.com:gsuscastellanosSC/hyperblog.git (cambiar url para que sea con ssh)


*************************************
**************Seguridad**************
*************************************

**********************************
***************TAGS***************
**********************************

git log --all(Muesta toda la historia)
git log --all --graph (Muestra toda la historia con la ineracci贸n de las ramas)
git log --all --graph --decorate --oneline
alias arbolito="git log --all --graph --decorate --oneline"(forma de alias en linux)

git tag -a v0.1 -m "apendiendo tags en git" (hash del commit) (crear un tag)
git show-ref --tags

git push origin --tags (enviar los tags al repositorio remoto)
git tag -d v0.1   && $ git push origin :refs/tags/v0.1 (Borrar tags)


**********************************
***************TAGS***************
**********************************

************************
********ramas***********
************************

git show-branch --all (驴Cuales branch existen y sus historias)
gitk (igual que la anterior per con gui)
git push origin :[nombre_branch] (Elimina rama remota)


************************
********ramas***********
************************

************************
***Crear fuente nueva***
************************

git remote add upstream (url-github)
git pull upstream master (trae todos los cabios de master del origen upstream)

************************
***Crear fuente nueva***
************************

F por Anita 馃槶

Apuntes 馃槳馃ゴ

F por Anita

1 Segundo de silencio por Ana... Gracias```

Para hacer una contribuci贸n a un proyecto de Github hay que seguir los siguientes pasos:

  1. Darle al bot贸n de Fork en Github
  2. Hacer los cambios y darle push a ellos en mi repositorio
  3. Hacer un pull request con mis cambios en alguna de las ramas del proyecto original y esperar
  4. Una vez aprueben o rechacen mis cambios ser茅 notificado en la cuenta de github

Pero tambi茅n pasa algo muy interesante y es que cuando yo he hecho un fork, el proyecto original sigue avanzando y el mio se va quedando atras, as铆 que para traer los cambios del proyecto original eso se hace de la siguiente manera:

  1. Crear una nueva fuente para hacer pull desde el repositorio forkeado. Por ejemplo:
    git remote add upstream [email protected]:freddier/hyperblog.git
    Nota: la palabra upstream es opcional pero es lo que normalmente se usa en la industria.
  2. Verificamos que hay una nueva fuente de datos con
    git remote -v
  3. Hacer pull de upstream/master
    git pull upstream master
  4. Hacer un commit para fusionar los cambios que hemos tra铆do
    git commit -am 鈥淔usion鈥
  5. Hacer un push para mandar los cambios a nuestro repositorio original
    git push origin master



Anita en estos momentos鈥

Todos los pasos del video aqui:
Sacamos a anita del proyecto (ya no tiene permisos de merge, push solo puede clonarlo).

Desde la cuenta de anita abrimos el proyecto, le damos watch(podemos ver conversaciones), estrellita (indicador de que este proyecto me gusta, me llegan avisos cuando algo cambia),y un fork es tomar una copia a nuestros repositorios (https://geeksroom.com/2014/05/que-es-un-fork-y-como-trabajar-en-github/85588/)
PARA HACER CAMBIOS DESDE LA CUENTA DE ANITA, HAY QUE TRAERNOSLO A NUESTRO PROPIO REPOSITORIO LOCAL.
Anita: $ git clone url_delRepoRemoto_de anita(el fork)
Modifico los errores ortogr谩ficos con entidades HTML y un commit ($git commit 鈥揳m 鈥淭ildes con entidades y mensaje de contribuci贸n鈥) y $git push
PARA PODER CREAR ESE PULL REQUEST (HACER UN MERGE) ENTRE UN PROYECTO Y OTRO
Le damos en new pull request nos abre esta interfaz y nos dice (Elija dos ramas para ver qu茅 ha cambiado y empezar un nuevo pull request. Si lo necesita, tambi茅n puede comparar los diferentes forks.)
Seleccionamos de derecha a izquierda (compare:master 鈥 mi master de mi repo) a base: master del repo original. Mas abajo vemos los cambios realizados.
Luego le damos en cr茅ate pull request y lo enviamos. Ahora toca esperar a que realicen estos cambios.

VAMOS A MI CUENTA:
Vemos que anita quiere fisionar un commit de su rama master a mi rama master.
Lo 煤nico que tenemos que preocuparnos es de cuales son los cambios.
Los aprobamos los cambios y le decimos OK y le damos Merge pull request(confirmo el merge).
Y vemos los cambios que ella hizo y si le damos a commits tambi茅n puedo ver los commits que anita realizo

ANITA EN ESTE MOMENTO TIENE UN FORK, LO QUE SIGNIFICA QUE SI YO HAGO CAMBIOS ANITA DEBE DE TRAERSELOS EN SU PROPIO FORK, PORQUE SE VA QUEDANDO ATR脕S.
Realizamos cambios al archivo original desde Willy (al title).
Nos traemos los cambios de anita con $git pull origin master. Nos lanza un error que dice tus cambios locales de tus siguientes archivos van a ser resuscritos por el merge (blogpost.html) no importa que este modificado el archivo.
Realizamos el commit ($ git commit -am "Cambio de titulo鈥) para que los fucione.(no genera ningun conflito).
Volvemos a ejecutar git pull origin master (si queremos fusionar los c芒mbios de la rama master com los cambios que realizamos en remoto)
$git push origin master (para enviar los cambios que yo hice)

EN ESTE MOMENTO ANITA TIENE UN PROBLEMA PORQUE HYPERBLOG (BLOG2) ESTA MAS ADELANTADO QUE EL DE ANITA. TENEMOS QUE TRAERLO
Anita: vamos al repositorio de anita desde su cuenta vemos los commits que hubieron
Podemos comparar y vemos los cambios de all谩 para aca para ver cambios.
Le podemos dar a cr茅ate pull request, esto me crea un pull request de Willy a anita darle merge y listo.

PARA TRAERME LOS CAMBIOS DESDE CONSOLA. CREAREMOS OTRA FUENTE PARA HACER PULL:
$ git remote add upstream url_https (esto para generar otra fuente nueva donde podemos traer datos a nuestra rama master)
$ git pull upstream master (con esto nos traemos todos los cambios de master)
$ git commit 鈥揳m 鈥淔usion鈥 (pero no hay nada a que hacerle commit porque ya nos traemos todo)
$ git push origin master (mandamos a nuestro repositorio original)

CONCEPTOS Y FUNDAMENTOS:
Fork: Significa tenedor, es tomar una copia del estado actual del proyecto y clonarlo como un proyecto mio. (SOLO PROYECTOS PUBLICOS,Y ES UNA CARACTERISTICA UNICA DE GITHUB.)

Hay dos maneras de actualizar mi fork del repo original, por consola o por github por consola simplemente hay que crear otra fuente remota para fusionar el remoto original con el fork en local y luego subirlo a el fork en remoto.

En esta clase m谩s all谩 de entender el PullRequest se ven las ventajas siendo un no-colaborador, simplemente alguien que quiera aportar.
La clonaci贸n a trav茅s de un Fork es similar a enlazar un repositorio:

  1. Hacer el Fork desde nuestro repo remoto
  2. Copiar la URL o SSH del nuestro repo bifurcado
$git clone URL o SSH (Clona el proyecto)

Para mantener actualizado este Fork es de utilidad tener un upstream que es un puntero a la rama master del proyecto principal, se logra enlazando una rama a la rama master del proyecto original:

$git remote add upstream URLdelOriginal (Enlaza con el master original)

A partir de upstream ya se pueden tener los cambios recientes en la rama master bifurcada.

Espero que les ayude.

鈥淎di贸s Anita, que la fuerza te acompa帽e鈥

驴Cu谩l es el Instagram de Anita?

segundo 20 del video y ya extra帽o a Anita :鈥(

Cuando no eres un colaborador directo, sino que es un proyecto open source, no puede hacer push o merge, porque no es tu proyecto. Lo que se puede hacer es un fork, hacer los cambios y decirles 鈥渜uiero colaborar, pro favor, revisen este c贸digo鈥.
En los proyectos open source para que te lleguen notificaciones de cu谩ndo se realizan cambios hay que darle clic al bot贸n 鈥渨atch鈥 y luego darle clic a fork, fork lo que hace es tomar una copia del proyecto y clonarlo, esto solo es posible si el proyecto es p煤blico, si el proyecto es privado es imposible saber que el proyecto existe.
Una vez el proyecto ha sido forkeado, aparecer谩 una copia en la interfaz del usuario en github, luego, se clona por https o ssh, y se importa en el disco local con 鈥済it clone URLDelProyecto鈥. Luego se hace un git commit, git push origin master, pero esto se actualizar谩 en tu repositorio, no en el repositorio oficial. Para hacer el pull request con la rama oficial, se debe crear un pull request, luego se coloca un t铆tulo, un comentario y luego enviarlo.
Desde la perspectiva del propietario, es el mismo procedimiento de code review, revisa los cambios y los acepta o no.
Ahora el proyecto oficial est谩 m谩s adelantado que el m铆o, desde github es tan f谩cil como revisar los cambios desde su interfaz visual, hacer un pull request de los cambios y luego un merge, nada del otro mundo, desde consola es lo interesante. se crea un nuevo origen remoto con git remote add nombreRemoto URLDelProyecto, y listo, ya se puede hacer pull del repositorio remoto oficial y luego push de nuestro repositorio remoto a github.

jejej

El fork es para personas que no est谩n como colaboradores, sin embargo pueden pedir y colaborar desde afuera, all铆 hace fork tomando una copia actual del proyecto, al hacer fork puedo ver todos los cambios que ha tenido el proyecto, luego para llevarlo a local, debe ir clone or dowland en el repositorio propio, y copiar la url , ir a la terminal git clone y la url, como es publica la trae completa.

All铆 puedo entrar a la carpeta y codificarla , luego de los cambios hacer git add . git commit -m 鈥渕ensaje鈥 git pull para buenas pr谩cticas y git push para subirlo a nuestro github

All铆 ya esta el repositorio con los cambios que adecue desde mi terminal, y para hacer un pull request que seria como un permiso para que hicieran merge a esos cambios, debo ir a pull request y new pull request, escoje las ramas que necesito usar que seria la que clone y la que modifique, le doy clonar y hago commit , cierro con create pull request .

De esta manera env铆o los cambios desde afuera del proyecto

A. Para bajarme Repo
Paso 1: Hacer Fork Directamente en GitHub
Paso 2: Hacer un clone del repositorio. (Mi Fork 鈥淐on mi nombre鈥)
Paso 3: Modificarlo
Paso 4: Hacer push (push origin master)
Paso 5: Hacer la petici贸n de una PullRequest (Hasta esperar aprobaci贸n)

B. Para Descargar cambios directamente del repositorio maestro (El due帽o es el Admin 鈥淨uien aprueba 贸 no las PullRequest鈥)
Paso 1: git remote add 鈥淣ombre (Preferencia upstream)鈥 + Url Repo
Paso 2: Verificar que se realizo correctamente git remote -v
Paso 3: Descargar cambios git pull upstream master
Paso 4: Mandar los cambios de upstream a nuestro origin git push origin master

Listo todo actualizado

Fork: crear una copia del estado actual del proyecto y clonarlo
Pull request de un tercero: a traves del fork gitHub reconoce el base repository/ base branch y el head repository/compare branch
Actualizar el fork desde consola:
git remote addd upstream url: agrega un nuevo repositorio remoto (apuntador al repositorio original el repositorio otiginal)
Nota: tambien se puede actualizar el fork desde gitHub a traves de un pull request

  • Una forma de contribuir a un proyecto sin ser colaborador es haciendo un fork del mismo.
  • Con esto tendremos una copia actualizada del repositorio en nuestro perfil para poder realizar cambios.
  • El proceso para poder contribuir a un proyecto es similar a hacer un pull request
  • Al hacer el pull request GitHub nos detecta que el proyecto es un fork para as铆 comparar las ramas del proyecto original con nuestra copia
  • NOTA: En caso de que el repo original sufra cambios, podemos agregar otra instancia del servidor remoto apuntando al original con $ git remote add, que por convenci贸n se puede nombrar upstream. Haciendo esto podremos traer actualizaciones del repo original con $ git pull upstream master, hacer nuestras modificaciones y mandarlas al fork con $ git push origin master y pedir el pull request.

Ahora si ya puedo apoyar en los proyectos OpenSource

Diferencia entre git pull y git clone:
git pull realiza una operaci贸n de fetch + merge de la rama especificada de un determinado repositorio.

git clone realiza una copia local de la rama activa de un repositorio remoto, incluyendo un seguimiento (remote-tracking) de todas las ramas, no solo de master. Las ramas existentes se pueden visualizar con git branch --remotes.

Si por alguna raz贸n no te deja hacer el push (como me paso a mi)
has esto:

git config --global --edit

[credential]
  helper = osxkeychain
  useHttpPath = true

F por Anita 馃槮

Noooooo. Anita馃檱鈥嶁檧锔忦煒


Que esta pasando?

Fredie y Anita como usuarios de github en el mismo PC


Al hacer el ejemplo con los dos usuarios no me dejaba hacer push al fork de Anita.

Si te ha pasado prueba agregar esta configuraci贸n local en el repositorio donde tienes el fork de Anita:

git config --local --edit

se abre un editor de texto y agregas las siguientes lineas al final:

[credential]
	useHttpPath = true

y ya puedes hacer push logueandote con tus credenciales de github.

Saludos

El comando git remote set-url origin https://github.com/USERNAME/REPOSITORY.git sirve para poder cambiar la url del reposiorio origin y el comando git remote rm origin sirve para eliminar un repositorio remoto.

De casualidad me equivoqu茅 en el nombre del remoto y le puse upstrem
Aqu铆 les dejo como cambiarlo por si por error ponen un nombre que no quieren:
$ git remote rename upstrem upstream

En el siguiente link encontraran un proyecto que estoy realizando en Java, lo estoy haciendo a la par mientras aprendo a usar correctamente git y gitHub, si es de su agrado pueden hacer fork, contribuir y as铆 nunca parar de aprender !!!

  • Si no eres parte del equipo, no podr谩s hacer push o merge al proyecto. Tendr谩s que hacer Fork al repositorio, despu茅s clonar el repositorio, hacer los cambios en tu repositorio y por 煤ltima hacer un pull request al due帽o del repositorio.

La cara de Freddy al ver que ahora tiene m谩s de 5k solicitudes de Pull requests 馃槀馃槀

Haciendo un fork鈥

Por problemas financieros tambi茅n tuve que despedir a Anita XD
si alguien quiere colaborar a mi open source si茅ntanse libres tambi茅n linkeen sus open source para que tambi茅n pueda colaborar con ustedes o puedan colaborar entre ustedes o todos colaboramos con todos o no se lo que suceda primero XD

Datos鉁嶐煆

馃搶 Fork

Es hacer una copia de un proyecto p煤blico a tu cuenta en GitHub.

Notas 馃搾

鉁忥笍 Hacer aportes a un repositorio que no es tuyo

Pasos:

  1. Realizar una bifurcaci贸n (fork) del proyecto de inter茅s.
  2. Clonarlo localmente en nuestra computadora. git clone [URL]
  3. Realizar las mejoras en nuestro repositorio local.
  4. Actualizar nuestro repositorio remoto con los cambios. git push origin main
  5. Solicitar que nuestros cambios sean agregados al repositorio original. pull request
  6. Esperar que sean aceptados.

鉁忥笍 Traer cambios del repositorio original

Hasta el momento se tienen dos formas:
La primera es:

  1. Crear un pull request entre mi repositorio y el repositorio original.
  2. Hacer el merge.
  3. Actualizar nuestro repositorio local. git pull origin main

La segunda forma es:

  1. Agregar el repositorio remoto original del proyecto (upstream) a nuestro repositorio local. git remote add upstream [URL]
  2. Traer los cambios con git pull upstream main
  3. Actualizar nuestro repositorio remoto. git push origin main

Despu茅s de buscar por una hora en las respuestas solo una fue acertada y la quiero compartir por si alguien a estas alturas sigue con este problema o se llega a topar
el problema:

la soluci贸n:
Ten铆a el mismo problema y encontr茅 esta soluci贸n en linea:
Hay una credencial en tu sistema de otra cuenta o de un proyecto anterior que debes eliminar. Si trabajas en windows 10 ve a
Panel de control\Cuentas de usuario\Administrador de credenciales\Credenciales g茅nericas,
busca las de github y qu铆talas.
Cuando vuelvas a intentar el push verifica la autenticaci贸n con el browser y asegurate de estar loggeado en la cuenta con la que estas trabajando o haber salido de la cuenta previamente para ingresar las credenciales.

Recuerden, que la notificaci贸n web de los forks no est谩n configurados por defecto, la notificaci贸n les llegar谩 solamente correo, pero pueden cambia la configuraci贸n en el icono de su avatar (settings/notifications) habilitan las que gusten

fork clonar repositorios
git clone ruta publica del proyecto
git diff
git commit -am "mensaje"
git push origin master
pull request
comparar los forks

git remote add upstream (link)
asi a帽adimos la fuente nueva rama para traer de github
git pull upstream master
git commit -am "fusion"
git push origin master

Una bifurcaci贸n (fork en ingl茅s) , en el 谩mbito del desarrollo de software, es la creaci贸n de un proyecto en una direcci贸n distinta de la principal u oficial tomando el c贸digo fuente del proyecto ya existente. Com煤nmente se utiliza el t茅rmino ingl茅s. Como resultado de la bifurcaci贸n se pueden llegar a generar proyectos diferentes que cubren necesidades distintas aunque similares.

Los cambios que se hacen en el repositorio original no se transmiten autom谩ticamente a la copia (fork). Esto tampoco ocurre a la inversa. Las modificaciones que se hagan en la copia (fork) no se transmiten autom谩ticamente al repositorio original.

Si quieres participar en un proyecto existente, en el que no tengas permisos de escritura, puedes bifurcarlo (hacer un 鈥fork鈥). Esto consiste en crear una copia completa del repositorio totalmente bajo tu control: se almacenar谩 en tu cuenta y podr谩s escribir en 茅l sin limitaciones.

驴Qu茅 es un fork?
La palabra fork se traduce al castellano, dentro del contexto que nos ocupa, como bifurcaci贸n. Cuando hacemos un fork de un repositorio, se hace una copia exacta en crudo (en ingl茅s 芦bare禄) del repositorio original que podemos utilizar como un repositorio git cualquiera. Despu茅s de hacer fork tendremos dos repositorios git id茅nticos pero con distinta URL. Justo despu茅s de hacer el fork, estos dos repositorios tienen exactamente la misma historia, son una copia id茅ntica. Finalizado el proceso, tendremos dos repositorios independientes que pueden cada uno evolucionar de forma totalmente aut贸noma. De hecho, los cambios que se hacen el repositorio original NO se transmiten autom谩ticamente a la copia (fork). Esto tampoco ocurre a la inversa: las modificaciones que se hagan en la copia (fork) NO se transmiten autom谩ticamente al repositorio original.

Para hacer un pull request, primero se debe hacer un fork. NO sirve clonar el repositorio simplemente desde el proyecto, porque github no har谩 la bifurcaci贸n del proyecto y no tendr谩 referenciado el repositorio original.

Hola me encuentro algo atorado con la practica de esta clase. he ido trabajando con las 2 cuentas desde un mismo ordenador. Lo que siempre hacia era cuando era anita Cambiaba el user name y el user email para identificarlos, pero cuando quiero hacer push siendo anita me sale el error de permission denied. Me podr铆an decir que podr铆a hacer ?.
lo que trato de hacer es que 鈥渁nita鈥 haga push a su propio Hyperblog, al cual le hizo un fork desde el original de 鈥淔reddy鈥. No deberia pedir permisos para que el propio due帽o de su cuenta haga push. O estoy equivocado?

Pobre Anita tan emocionada que estaba en su nuevo trabajo. Paso de colaborador pagado a contribuyente sin paga. 馃槄

Hacer un Fork es tomar una copia del estado actual del proyecto remoto p煤blico y clonarlo como un proyecto propio.
Es una caracter铆stica de Github.

Primero se debe clonar el repositorio remoto
$git clone http://url

Si mi proyecto clonado local est谩 desactualizado porque le faltan nuevos commit del propietario del proyecto lo que se puede hacer para obtener estos cambios es lo siguiente:

Se crea una nueva fuente de datos remota:

$git remote add nombre_fuente url_publica_https
$git remote add upstream https://github.com/鈥

Se valida que exista la nueva fuente remota:
$git remote -v

Se realiza un pull de la fuente remota a mi master local
$git pull upstream master

Actualizo mi repositorio remoto de github subiendo los cambios que tengo en mi master local
$git push origin master

uff entend铆 el concepto, sin embargo se me ha hecho m谩s complicado, a repasar.

馃搶 Fork permite realizar una copia exacta del repositorio original para trabajar sobre ella.

Ahora si se pone un poco complejo

Un fork permite clonar el estado actual de un proyecto a github para que posteriormente puedas descargarlo, realizar los cambios correspondientes y posteriormente hacer un pull request para su aprobaci贸n

Bueno esta confuso, tal vez es la falta de practica.

Proceso para colaborar en un repositorio donde no soy colaborador.

  1. Busco el repositorio y uso la opci贸n 鈥榝ork鈥
  2. Con el repositorio en mi bandeja, lo clono en mi m谩quina (clone with HTTPS o SSH).
  3. Con el repositorio en mi entorno local, hago los cambios, hago commit y hago push
  4. El push queda en el respositorio remoto de mi cuenta.
  5. Con ese push hecho, puedo generar un pull request al due帽o del repositorio original (del cual hice fork)
  6. En el pull request puedo especificar en qu茅 consiste la mejora

Una vez el due帽o del repositorio ingrese a GitHub, va a poder:

  1. Ver que hay un 鈥榗ontributor鈥 que gener贸 un pull request
  2. Validar el pull request y aceptarlo o rechazarlo
  3. Si lo acepta, luego tendr铆a que hacer el merge pull request

El due帽o puede seguir trabajando, lo que genera que el contributor empiece a rezagarse. GitHub le va a decir al contributor que est谩 N commits detr谩s del owner. El contributor puede solicitar un pull request a su repositorio y siendo due帽o de su repositorio darle merge (opci贸n GitHub-first). Esto mismo se puede hacer tambi茅n por consola (Terminal-first):

# Siendo el colaborator, origin es mi repositorio remoto, no el remoto del owner
# verifico la conexion a origin
$ git remote -v
origin https://github.com/contributor_user/hyperblog.git (fetch)
origin https://github.com/contributor_user/hyperblog.git (push)

# como quiero traer la ultima actualizacion del repositorio del owner, debo copiar la URL para clone en el repositorio de owner.
# upstream es una manera generica de llamar al repositorio del owner
$ git remote add upstream [url clone del owner]

# verifico conexiones
$ git remote -v
origin https://github.com/contributor_user/hyperblog.git (fetch)
origin https://github.com/contributor_user/hyperblog.git (push)
upstream https://github.com/owner_user/hyperblog.git (fetch)
upstream https://github.com/owner_user/hyperblog.git (push)

# actualizo repositorio local:
$ git pull upstream master

# ahora, mi repositorio local esta mas adelantado que mi repositorio remoto debido al pull. Actualizo el remoto:
$ git push origin master

Entonces basicamente es posible copiar un proyecto que nos guste, realizarle modificaciones a gusto y en tal caso logremos mejorarlo realizar una Solicitud para unir nuestros cambios con el repositorio al que le realizamos la copia.

Luego si existe la posibilidad de que el repositorio original este actualizado entonces podemos actualizar el nuestro ya sea por Github o por la terminal de nuestro repositorio locar a帽adiendo la URL del repositorio Originial.

A un 鈥済it remote add <URL>鈥 y de esta forma aunque no podamos realizar un git push porque no estamos autorizados, si que podememos realizar un git pull

colaborador -> puede hacer merge, push,
watch -> notificaciones de la actividad realizada en dicho repositorio remoto (RR).
start -> indicador de me gusta.
fork -> tomar una copia del estado actual del proyecto publico pero en un repositorio local, debido a que no es un colaborador, caracteristica github.

Pasos para contribuir o realizar una copia de un proyecto publico en github:

  1. Presionar fork, para tener el RR a contribuir a nuestro propio RR.
  2. Copiar link en clone, elegir entre HTTPS o SSH del RR a contribuir.
  3. En la carpeta deseada se clona el repositorio:
        git clone url
  1. Realizar cambios y enviar estos al RR.
  2. Crear un Pull requests, dependiedno de la rama trabajada se pueden realizar comparaciones.
  3. Esperar revisi贸n de los cambios y la realizacion del 鈥榞it merge pull requests鈥.

Pasos para realizar una copia de un proyecto publico en github desde terminal:

  1. crea otra fuente de donde se puede traer la fuente de datos desde el RR a contribuir:
        git remote add nuevaRamaRemota link

NOTA: nuevaRamaRemota es usualmente llamada upstream (fuente de origen del RR a contribuir).
  1. Traer todo los cambios de RR a la rama main al repositorio local:
        git pull nuevaRamaRemota main
  1. Fusionar repositorio, por si hay cambios
        git commit -am "comentario"
  1. enviar cambios en el repositorio remoto propio:
	git push origin main

NOTA: los envios de cambio deben ser solo desdes las ramas del repositorio local propio a nuestro RR.

git branch ->

Flag ->
    	 --all -> muestra las ramas locales y remotas del repositorio.

Nunca te olvidaremos Anita :,v

Es un dolor de cabeza entender todo esto, pero estoy mucho mejor de cuando empece Cx. No puedo esperar para crear mis blogs y contenido

Crear un nuevo origen para actualizar mi repositorio local forkeado con los 煤ltimos cambios del repositorio original

Es la tercera vez que miro este video, pues tuve que regresar para hacer el reto del video 31, para hacerle el Pull Request a Freddier.
No entend铆a que al hacer un FORK, se crea un proyecto en mi GitHub y que a partir de 茅ste se debe realizar el 鈥渃lone鈥 en mi Git para aportar y entonces subirlo a GitHub (proyecto forked) y ahora si se puede aplicar el Pull Request.

F por anita 馃挃

Watch: Funciona para tener un seguimiendo sobre el proyecto, en el caso que salgan conversaciones nuevas o alguna otra cosa

Start: Funciona para darle favorito al proyecto por si sale una actualizacion te avisaran

Fork: Es una opcion para hacer una copia del proyecto publico a tu repositorio de GitHub, directamente esta es una cualidad que solamente encontramos en GitHub y no en Git. De esta forma podremos utilizar practicamente el proyecto como si fuera de nosotros haciendo todos cambios sin efectar al proyecto principal y sin tener una conexion alterna o directa a el.


Para colaborar en un proyecto es util un pull request.

Primero creamos un FORK de el proyecto principal a nuestro perfil(github), despues lo traemos a nuestro repo local(git clone URL_del_fork).

Despues de haver echo cambio en nuestro FORK podemos enviar los cambio al proyecto principal mediante un pull request y seran implementados si el due帽o los decide implementar.

saviendo que habran cambios en el proyecto principal nuestro FORK se quedara desactualizado.

Para tener actualizado nuestro FORK y nuestro repositorio en la PC, podemos crear un nuevo apuntador remoto al repocitorio del creador(git remote add upstream URL_del_creador).
Despues podemos traer actualizaciones a la PC(git pull upstrear master), y lo podemos enviar a nuesro FORK en github (git push origin master).

Sin el gorro no distingo qui茅n es Anita y qui茅n es Freddy 馃槮

Hola buenas tengo una duda para los respectivos cambios siempre tengo que estar pendiente del repositorio o eso se notificaria que eso no quedo 100% claro

Habr铆a diferencia entre a帽adir un remoto con el SSH url en vez del HTTPS url ?

Es una caracter铆stica 煤nica de GitHub en la que se crea una copia exacta del estado actual de un repositorio directamente en GitHub, 茅ste repositorio podr谩 servir como otro origen y se podr谩 clonar (como cualquier otro repositorio), en pocas palabras, lo podremos utilizar como un git cualquiera
.
Un fork es como una bifurcaci贸n del repositorio completo, tiene una historia en com煤n, pero de repente se bifurca y pueden variar los cambios, ya que ambos proyectos podr谩n ser modificados en paralelo y para estar al d铆a un colaborador tendr谩 que estar actualizando su fork con la informaci贸n del original.
.
Al hacer un fork de un poryecto en GitHub, te conviertes en due帽@ del repositorio fork, puedes trabajar en 茅ste con todos los permisos, pero es un repositorio completamente diferente que el original, teniendo alguna historia en com煤n.
.
Los forks son importantes porque es la manera en la que funciona el open source, ya que, una persona puede no ser colaborador de un proyecto, pero puede contribu铆r al mismo, haciendo mejor software que pueda ser utilizado por cualquiera.
.
Al hacer un fork, GitHub sabe que se hizo el fork del proyecto, por lo que se le permite al colaborador hacer pull request desde su repositorio propio.

Por fin aprendo como funcionan los proyectos open source en GitHub, a ver si puedo apoyar en alguno鈥 馃槂

Noooo anitaaaaa, no hizo nadaaa, sueltenlaaaa

Clase 29. Creando un Fork, contribuyendo a un repositorio

驴Qu茅 es?

Es una caracter铆stica 煤nica de GitHub en la que se crea una copia exacta del estado actual de un repositorio en GitHub, 茅ste repositorio podr谩 servir como otro origen y se podr谩 clonar (como cualquier otro repositorio), en pocas palabras, lo podremos utilizar como un git cualquiera.
Al hacer fork los archivos se quedan en GitHub, no en GIT. Para llevarlos a nuestro repositorio local hacemos una clonaci贸n.

驴C贸mo se hace?

La clonaci贸n a trav茅s de un聽fork聽es similar a enlazar un repositorio:

  1. Hacer el Fork desde nuestro repo remoto

  2. Copiar la URL o SSH del nuestro repo bifurcado

    $git clone url-o-ssh

  • Una vez hecho esto podemos acceder a los archivos desde nuestro repositorio local. Si hacemos unos cambios en los archivos y hacemos un commit, al ejecutar git status Git nos dir谩 que estamos por delante de la rama original de internet. Para actualizarla hacemos un git push y enviaremos los cambios a GitHub.
  • Estando en GitHub podemos hacer un new pull request donde podemos comparar los diferentes forks o las ramas de mi repositorio con las del original. Hay que recordar un pull request indica que es lo que cambiara en los archivos si se hace un merge.
  • Este pull request se env铆a al due帽o del repositorio original que es quien tomara la decisi贸n de aceptar o no los cambios y hacer un merge entre las ramas.

Si el due帽o del repositorio hace cambios en los archivos nosotros tendremos un fork desactualizado. GitHub nos ayuda con eso y nos dice que estamos desactualizados, tambi茅n nos ayuda a comparar esos cambios. Para mantener actualizado este fork es de utilidad tener una聽rama fuente que apunte a la rama master del proyecto principal. Normalmente a esa rama se le llama upstream y lo hacemos de la siguiente manera:

git remote add upstream url-del-original

Una vez hecho esto ejecutamos un git pull upstream master para traernos esos cambios que est谩n en la rama upstream a nuestra rama master y ahora si estamos listos para mandar esos cambios a GitHub con git push.

Esto se puede hacer de la manera inversa, es decir, que GitHub se traiga los cambios del repositorio original al nuestro, y despu茅s traernos esos cambios a nuestro repositorio local. Ambas son validas y funcionales depende de ti cual usa

RESUMEN

  • Cuando alguien deja de ser colaborador de un proyecto en GitHub, lo que puede hacer es copiar el proyecto y decir que quiero hacer un cambio, por favor fusi贸nenlo.
  • Pasos para colaborar en un proyecto de GitHub
    • Darle Watch y Star para indicar que el proyecto te gusta.
    • Podemos hacer un Fork, es tomar una copia del estado actual del proyecto y clonarlo. Esto solo se puede hacer con proyectos p煤blicos.
    • Traemos el proyecto a nuestro disco con git clone [url].
    • Podemos hacer los cambios necesarios en local.
    • Una vez hecho los cambios, podemos enviar los cambios a nuestro repo remoto con git push. No es necesario colocar origin master
    • Luego debemos crear el Pull Request, donde podemos hacer las comparaciones entre las diferentes ramas.
    • Una vez hecho el PR, nos queda esperar a que el administrador quiera aceptar los cambios y haga el merge o tambi茅n puedo cerrar el PR y rendirme.
  • Ahora el admin vera el PR y sus cambios, y podr谩 aceptar los cambios para hacer el merge o rechazarlos y hacer comentarios.
  • Una vez el proyecto original va cambiando, el Fork va quedando atr谩s, por lo tanto siempre tengo que traerme los cambios para estar actualizado.
  • Para actualizarlo tenemos dos opciones:
    1. Por GitHub: Puedo hacer una comparaci贸n de los cambios, y GitHub nos da la opci贸n de hacer un PR desde del admin hacia mi, y simplemente hacer el merge.
    2. Por Consola:
      • Creamos una rama remota que nos traiga los cambios del repo original git remote add [rama] [url-proyecto], la rama suele llamarse upstream.
      • Verificamos si se ha creado correctamente la rama con git remote -v donde debemos tener las dos ramas: origin y upstream.
      • Hacemos un git pull upstream mainpara traernos todos los cambios de main.
      • Por ultimo hacemos un git mull origin master para mandarlo a nuestro repo remoto.
  • Ambas formas son 100% validas, podemos usar la 1era y luego migrar a consola.

馃FUNCIONAMIENTO DE FORK鉁

Al trabajar en un proyecto Open Source, nosotros no tenemos los permisos de realizar un merge o un commit directamente en la rama main del proyecto. Por lo que si queremos realizar una colaboraci贸n por nuestra cuenta necesitamos realizar un fork, es decir, realizar un clon del repositorio original en GitHub pero en nuestra cuenta personal.
.
Una vez realizado el fork en GitHub, para poder editarlo de manera c贸moda debemos clonarlo en nuestro repositorio local (s铆, el clon local de un clon remoto).
Cuando hayamos realizado los cambios debemos hacer un push de dichos cambios a nuestro clon remoto y posterior, realizar un Pull Request hacia proyecto original y esperar la aprobaci贸n/desaprobaci贸n, solicitud de cambios de la persona encargada de los commits del proyecto y as铆 poder realizar nuestra contribuci贸n.
.
Los proyectos no se detienen, as铆 que siempre hay nuevas versiones y commits, por lo que nuestros clones estar谩n desactualizados de dichas versiones.
Una soluci贸n para este problema es actualizarlo directamente desde la opci贸n que nos ofrece GitHub, es decir:

  • Actualizar el repositorio clon remoto desde la herramienta que nos ofrece GitHub.

  • Realizar un pull a nuestro clon local.

  • Y continuar con las contribuciones.

Pero existe otra soluci贸n m谩s practica desde la terminal que consiste en crear otra fuente para realizar pull, es decir:

  • Crear una nueva versi贸n/fuente de datos local que est茅 conectada directamente con el repositorio remoto original, para que pueda actualizarse constantemente.
git remote add [nombreDeLaNuevaFuente] [linkDelRepositorioRemotoOriginal]
  • Con esta nueva fuente tenemos la capacidad de realizar un pull a nuestro clon local desde la nueva fuente para estar constantemente actualizados.
Nota: Un versi贸n local solo puede estar conectada a un repositorio remoto, por eso es importante crear otra fuente para traer cambios de un repositorio y enviarlos a otro.

/ clase 29 --> Creando un Fork(Contribuci贸n open source) /

watch --> Notifica cambios en el proyecto.
star -->  Da a entender que te gusta el proyecto.

git clone [url] --> Clona un repositorio.

git diff --> Muestra los cambios.

FORK (bifurcaciones): Pull request de alguien que no es colaborador.

En un entorno profesional de desarrollo.
驴Se utilizar铆a un Fork?

Me gust贸 m谩s la versi贸n de consola, es m谩s f谩cil i r谩pido, lo 煤nico que haces es agregar la URL (llamada upstream) que apunta al proyecto original y usarla para descargarte todos los cambios, por eso la consola es m谩s r谩pida jaja

Si alguien quiere practicar sus Pull Request o Fork
Use la misma base que Freddy para hacer un blog. Si quieren implementar cambios, agreguen sus propios branch,

Repositorio de Prueba

Pobre Anita :c

Tuve un error, era que en ves de clonar el protocolo http copie el SHH, y por eso me sali un error de permiso denegado, y por eso me toco hacer el merge desde github. Aprend铆 del error que es lo importante

Hay un modo de que el alias 鈥淎rbolito鈥 quede guardado para siempre?
Cada vez que vuelvo a iniciar Git me toca volver a crear el alias, o simplemente no se puede?

Anita estaba muy emocionada por su empleo, y freddy tuvo que despedirla 馃槮

Para agregar una nueva fuente de datos:

  • git remote add (cualquierPalabraDescribaOrigenDatos) link_del_repositorio

Explicaci贸n

git pull upstream master para traer los cambios a nuestra rama master

Noooo Anita :C

Incluso puedes agregar varios origenes remotos que apunten ya sea a gitlab, github o un git server privado, siempre y cuando tengas tus llaves configuradas correctamente.

Me agradaba Anita

Cada vez mas claro 馃槃

chingon! despues de agarrar pericia en proyectos con amigos, me gustaria contribuir con desconocidos

Fork: Es tomar una copia del estado actual del proyecto y clonarlo. Se usa para poder contribuir a un proyecto sin ser colaborador.

Para mantener un fork actualizado con el proyecto original es necesario:

  • Agregar un origen remoto con el URL original
    $git remote add upstream 鈥淯RLoriginal鈥

  • traer cambios del upstream al master local
    $git pull upstream master

  • subir los cambios a nuestro fork
    $git push origin master

FORK: Copia del estado actual del proyecto y clonarlo, esto nos permite mandar un pull request del proyecto si es necesario, incluso si no eres parte de 茅l (s贸lo un contribuyente).

el fork no resulta ser unico de gitHub actualmente tambien se puede hacer fork en bitbucket

Freddy es un gran capo.

Se entendi贸 perfecto!!