¿Qué es GitHub? ¿Qué es Git? Y cómo utilizar estas herramientas de desarrollo.

Los primeros programas que escriba probablemente no serán muy impresionantes. Cometerá muchos errores y nunca querrá volver a visitar el pasado.

Pero pronto, estará escribiendo programas grandes y complejos. Quizás elimine algunas cosas ahora que quiera traer de vuelta más tarde. O tal vez traerá a un amigo para que lo ayude y desee agregar con elegancia sus cambios a su programa mientras continúa trabajando en sus partes.

Ahí es donde entra el control de versiones , y es una habilidad que cualquier empleador esperará que domine. También es extremadamente útil para cualquiera que esté trabajando en cualquier cosa que esté guardada en pedazos, desde un programa de computadora hasta una receta o una novela.

¿Qué es el control de versiones?

El control de versiones se refiere a la capacidad de guardar su lugar en un documento o carpeta y hacer referencia a guardados anteriores.

Mientras escribo este artículo, mis cambios más recientes sobrescriben constantemente mis versiones anteriores. No es control de versiones, porque no puedo volver al borrador que tenía hace una semana. Pero si escribiera esto usando Git, sería posible.

¿Qué es Git?

Git es un sistema de control de versiones desarrollado por Linus Torvalds en 2005 (el mismo que escribió Linux). Git ayuda a los desarrolladores a realizar un seguimiento del estado de su código y permite la colaboración en una base de código. Repasaremos los componentes principales un poco más tarde.

Si desea seguir adelante, deberá tener Git instalado en su computadora. Abra una terminal y escriba git. Si ve una lista de posibles comandos, ¡está listo!

Muchas computadoras vienen con Git ya instalado. Si necesita instalar, puede seguir las instrucciones aquí para su computadora.

Usando Git

Si alguna vez usó un programa de computadora o un videojuego y notó que puede volver a una versión previamente guardada, comprende inherentemente la necesidad de Git. Es simplemente guardar una instantánea de su programa a tiempo.

Pero en lugar de tener que realizar un seguimiento de cada línea de código en su programa, en su lugar toma nota de los cambios entre el código que tiene ahora y la última vez que guardó. Mantiene una nota actual de cuándo se guardó por última vez cada línea de código y las almacena en una carpeta oculta especial.

Consideremos este programa JavaScript. Imprime tres líneas en la consola (una salida que puede ver en su navegador o terminal):

console.log('Hello, this is a git example!') console.log('And here is another!') console.log('And yet a third') 

git init

Si quiero guardar versiones de mi trabajo, puedo usar Git. Primero, escribiré git initen mi terminal para poder comenzar a usar Git. Eso creará una .gitcarpeta, donde Git almacenará sus archivos.

git agregar

git add .agregará todos los archivos en nuestro programa. Si lo hizo git initdespués de crear un archivo, o cada vez que cree archivos nuevos, tendrá que decirle a Git que comience a rastrear los cambios con este comando.

git commit

A continuación, escribiré git commit -am "Initial commit". git commites el comando para guardar una versión de nuestro código. Se -amllama "bandera" y señala que hay acciones opcionales que nos gustaría realizar con esta confirmación. La bandera asignifica que vamos a guardar todos nuestros cambios. La bandera mindica que proporcionaremos un mensaje después, que es "Initial commit".

Puede escribir lo que quiera aquí: freeCodeCamp tiene muchos artículos sobre cómo escribir excelentes mensajes de confirmación.

Cómo guarda Git los cambios

Si hacemos un cambio en nuestro programa (como cambiar el texto de la primera línea), es posible que queramos guardar una versión. Incluso podríamos alternar entre versiones si quisiéramos ver cómo nuestro programa ha cambiado con el tiempo.

console.log('Now I have changed the first line.') console.log('And here is another!') console.log('And yet a third') 

git diff

Así es como se ve esto mientras corres git diff. Git le mostrará la diferencia entre el código que tiene ahora y la última vez que lo guardó.

Es un poco difícil entender lo que está sucediendo aquí, pero -hay eliminaciones y +son inserciones. Eliminamos el texto "Hola, este es un ejemplo de git". y agregó el texto "Ahora he cambiado la primera línea". Así es como Git realiza un seguimiento de lo que ha cambiado entre versiones.

diff --git a/git.js b/git.js index eb0f1d1..8dbf769 100644 --- a/git.js +++ b/git.js @@ -1,3 +1,3 @@ +console.log('Now I have changed the first line.') -console.log('Hello, this is a git example!') console.log('And here is another!') console.log('And yet a third')

Ahora que hemos revisado los cambios que estamos cometiendo, podemos seguir adelante y hacer una segunda comprometerse: git commit -am 'Update first console log'. Esto guardará los cambios que hice en la primera línea de texto.

registro de git

Podemos revisar las confirmaciones que hemos realizado con el comando git log. Si lo ejecuto en mi programa ahora, obtengo este resultado:

commit 67627dd44e84a3106a18a19e94cf9f3723e59b3c (HEAD -> master) Author: amberwilkie  Date: Wed Apr 22 16:55:39 2020 -0400 Update first console log commit 49fe4152f474a9674a83e2b014a08828209d2690 Author: amberwilkie  Date: Wed Apr 22 16:54:59 2020 -0400 Initial commit

Vemos nuestros mensajes de confirmación, el tiempo que nos comprometimos y un ID único para nuestra confirmación, que podemos usar para hacer referencia a las confirmaciones en el futuro.

git checkout

Si quisiéramos volver atrás y ver los cambios en nuestro código de una confirmación anterior, lo haremos con git checkout 49fe4152f474a9674a83e2b014a08828209d2690. Git pondrá nuestro código en un estado temporal para que podamos ver cómo se veía el código en esa instantánea a tiempo.

Copié la identificación para mi primera confirmación. Si ejecuto este comando, mi programa dice "¡Hola, este es un ejemplo de git!" en la primera línea.

Para volver al código más reciente, escriba git checkout master.

Ramas

Si lo notó anteriormente, tuvimos que escribir masterpara volver al estado actual de nuestro código. ¿Por qué? Porque masteres el nombre predeterminado para la sucursal de sucursales, el lugar donde nuestro código está más actualizado.

Git se basa en la ramificación para mantener nuestro código. Puede considerar masterel tronco de su árbol de código. Puede interrumpir y hacer algunos cambios, pero el objetivo final es siempre llevarlos de vuelta al maletero, a master.

You can use git checkout to make a new branch, not just to check out previous versions of your code. Try git checkout -b new-branch. The -b flag is used when we are making a new Branch and after the flag we write the name of our new branch. We can make many commits on this branch and later get them back to master with a process called merging.

In the diagram below, the dots represent commits. Two branches have been made "off" of master. In software development, we often call these "feature" branches, as opposed to the main master branch. The blue branch has been merged back into master and the yellow branch is still being developed.

Note that even though the yellow branch was created after the blue branch, only changes from master will be visible in that branch. If we made a third branch sometime in the future, changes from both master and the blue branch would be present in the new, third branch.

git merge

git merge will take all the commits you've made on that branch and stick them into the master branch, saving your work.

Why use branches?

If you're working alone, it may not make a lot of sense to split your work into branches. Why not just save everything on master?

The utility of branching does not become very clear until we start thinking about working on a team of developers. If they were all committing to the master branch every time they made a change, things would get very messy very quickly. It would also be difficult to control what code goes "to production" (live to customers) and which code is still being tested or worked on.

This way, every developer can have their own branch (or, likely, many), work on their feature for as long as they need, and merge it when the time is right.

What is GitHub?

GitHub is a free (for personal use), cloud-hosted platform for code. It works with Git on your and your colleagues' computers, serving as the origin, the source of truth for anyone working on the code.

You and your collaborators upload their code to GitHub periodically, and GitHub provides tooling to help manage changes to the code over time.

Uploading your code to GitHub

First, you'll need to create a GitHub account. You'll use this account for your entire programming career, so hot tip: stick with a professional name, preferably with your actual name in it.

Once you're in, look for a + in the top corner. Click "New Repository" (the name for Git folders, "repo" for short). Give it a name - probably the same as the folder you created earlier where you've saved your commits. Then click "Create Repository". You can now copy the url you are redirected to and we can set the origin for our code.

There will be an authentication step at some point here - just follow the directions. Git is very good about giving us clear instructions on the next steps to take.

git remote add origin

Now we will tell our codebase (the folder where our code is) where to store our code in the cloud. We'll type git remote add origin , which will set an origin for our repository.  Now we can push to our origin to store our cloud at GitHub.

git push

Assuming we're still in our master branch (that is, we have not checked out another branch), we can now type git push and our code will go to GitHub.

Viewing your code

Now your code lives in GitHub! Here's what my example from above looks like after I follow the GitHub steps I've explained:

You can click through the files and folders of your repository, viewing the current state of the code. You can also view previous versions of the code, by clicking "X commits" on the right side, middle. You'll see a list of the commits made to the repo and if you click into them, you can browse the files of your project as they existed at that slice of time.

Pull Requests

There are many other features of GitHub, but the most important in collaborating with colleagues is a pull request. A pull request (very frequently shortened to PR) is a way to manage incoming changes to the code base.

To make one, you'll make a new branch on your local computer, create at least one commit on that branch, then git push origin head to send that branch to GitHub. (You can put the name of your branch instead of head but it's useful for keeping everything matched up exactly).

Now when you go back to GitHub, you should see your branch available to make a PR.

If you click the "Compare & pull request" button, you'll be able to change many settings for your PR. Most important are generally title and description. If you're working on a team, you can tag colleagues to ask them to review your code, add to projects, and many other features you probably don't care about yet.

Note that we are comparing branches. Here we are requesting to add the changes from this branch (pr-example) into the master branch. But we could target any of the other branches in our repo. For now, just understand that master isn't the only branch you can "make a pull request against".

When you click "Create Pull Request", you'll see this screen:

You can see all the commits in this branch (I have only one - "Change third line of program"), and you can also merge your pull request.

Remember how we could merge our code locally when we talked about Git? We can perform the same action with our cloud-hosted code on GitHub. If you click the green "Merge pull request" button, your changes will be merged into master.

git pull

The last command you need to know right now is git pull. If you merged your PR into the master branch on GitHub, there are now changes to the origin that you do not have yet on your local computer. If you check out the master branch, then git pull origin master, the changes you have just merged will now be on your local computer.

➜ git-example git:(master) git pull origin master From //github.com/AmberWilkie/git-example * branch master -> FETCH_HEAD Updating 67627dd..38ad2da Fast-forward git.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

That "Fast-forward" refers to our local master branch "catching up" with the origin branch on GitHub. We have completed the circle:

  • Local changes
  • Push to GitHub and make PR
  • Merge PR into master
  • Pull master to local computer

Once you are comfortable with these steps, you will be 80% of the way to mastering Git and GitHub!