Forem: Joel Hanerth

Initial introduction to Git and github

Joel Hanerth — Thu, 19 Sep 2024 14:41:57 +0000

If you're a developer or just starting to program, you've probably heard of Git and GitHub. These tools are essential in the world of software development, especially for those working in teams or on open-source projects. But what exactly are they, and why are they so important?

What is Git?

Git is a distributed version control system created by Linus Torvalds in 2005. It allows developers to track changes in code, collaborate on different features, and revert changes when necessary. Git makes team collaboration easier since each developer can have their local copy of the repository and integrate their contributions into the main project in a controlled manner.
Version control is also extremely useful for maintaining the project's history, enabling you to "go back in time" and see how the code evolved, or even revert to a previous state if something isn't working as expected.

What is GitHub?

GitHub is an online platform that hosts Git repositories. It adds a user-friendly interface and several extra features to collaborate with other developers. Besides storing repositories, GitHub offers tools such as pull requests, issues, and projects, making collaboration management and tracking bugs and new features easier.
Another important point is that GitHub has become one of the main platforms for open-source development, allowing developers worldwide to collaborate on a wide variety of projects.
With Git and GitHub, you not only have a powerful way to manage code locally but also a space to share your work and collaborate globally.

How to create a repository on GitHub:

1. Access GitHub: Log in to your GitHub account. If you don’t have an account, create one at github.com.

2. Create a new Repository:

In the upper-right corner of the screen, click the "+" icon and then click New repository.
Fill in the repository information:
- Repository name: Give your repository a name (for example, "my-project").
- Description (optional): Add a brief description of the project.
- Choose whether you want the repository to be Public or Private.
You can check the option to add a README file if you want the repository to have an initial description.

3. Create the Repository:

After filling in the details, click Create repository.
GitHub will create the repository and show the repository URL, which you will use to clone it into your Visual Studio.

Cloning the repository in Visual Studio

Now that you've created the repository on GitHub, you can clone it to your local machine and start working on it.

Steps to clone a repository in the Visual Studio terminal:

Open Visual Studio.
Open the Integrated Terminal.
Navigate to the desired folder.
Use the git clone command:
- In GitHub, copy the repository URL (HTTPS or SSH).
- In Visual Studio's terminal, type the following command:

   git clone <repository_url>

5.Result:

Git will clone the repository into the current folder, and you'll see something like this in the terminal:

   Cloning into 'my-project'...
   remote: Counting objects: 100, done.
   remote: Compressing objects: 100% (XXX/XXX), done.
   Receiving objects: 100% (XXX/XXX), done.

6.Navigate to the Cloned Repository:

Now, go to the folder of the cloned repository:

   cd my-project

YOU’RE READY TO START!

Note: If you haven’t previously configured Git on your machine, you won’t be able to clone the repository successfully. Before trying the git clone command, ensure Git is configured using the following commands in the terminal:

git config --global user.name "Your Name"
git config --global user.email "youremail@example.com"

These commands configure the global username and email in your Git environment, which will be used when making commits. If Git isn’t configured, you may encounter errors when interacting with repositories.

Let's get to work!

Now that you've cloned your repository, let's create a file, add it to version control, and explore Git's essential commands.

Creating a File and Using Basic Commands

1. Create a file:

In Visual Studio, create a new file at the root of your project, for example, a file named index.html. In the terminal, you can do this with the command:

touch index.html

Or simply create the file in the Visual Studio editor.

2. Check the Repository Status:

To see what has changed in your repository, use the git status command:

Untracked files:
  (use "git add <file>..." to include in what will be committed)
      index.html

This means Git has detected the index.html file but is not tracking it yet.

`git add` Command

3. Add Files to Version Control:

To start tracking changes to a file, use the git add command:

git add index.html

If you want to add all modified or created files, you can use:

git add .

Now the files are ready to be committed.

`git commit` Command

4. Committing Changes:

A commit records changes to the repository. To create a commit, use the command:

git commit -m "Adds index.html file"

Note: The -m flag allows you to add a descriptive message for the commit.

`git log` Command

5. Check Commit History:

To see the history of commits made in the repository, use the git log command:

git log

This is the default log option, but Git offers some useful options to simplify and customize the git log output.

Using git log --oneline

The oneline mode compresses the display of commits into a single line per commit, showing only the short hash and commit message. Command:

  git log --oneline

Using git log --graph

The git log --graph command displays the commits in a graph format, allowing you to visually see the structure of branches and merges. Command:

  git log --graph

Combining git log --graph --oneline --all

You can combine several options for a more comprehensive and simple view of the commit history. Combining --graph, --oneline, and --all (which shows commits from all branches - you can know more about branches here) is particularly useful for a clear view of the project's history. Command:

  git log --graph --oneline --all

Output (example):

  * a1b2c3d (HEAD -> master) Adds new feature
  | * 9e8f7g6 (feature) Fixes bug in feature branch
  |/
  * 5h4i3j2 Refactors code for improvements

`git checkout` Command

This command has multiple uses, but I'll cover just two:

6. Revert Changes:

If you make changes to a file and want to return to the last committed state, use the git checkout command:

git checkout index.html

This will undo changes made to index.html that haven't been committed yet.

7. View Project at a Specific Commit:

You can use the git checkout command to "look" at how the project was at a particular commit:

git checkout [commit_hash]

Pushing and Updating the Remote Repository

Now that you've made local changes, you might want to push these changes to the remote repository (GitHub) or pull the latest changes someone else made in the repository.

`git pull` Command

8. Update Local Repository:

Before pushing your changes, it's a good practice to ensure your local copy is up to date with the remote repository. To do this, use:

git pull

The git pull command brings changes from the remote repository to your local machine.

`git push` Command

9. Push Your Changes to the Remote Repository:

Now, you can push your local commits to GitHub with the git push command:

git push

This will push your changes to the master or main branch on the remote repository.

Did you like the post 🤔? Are you interested in learning more about Git features? Visit: Introduction to branch 😉

Introdução Inicial ao git

Joel Hanerth — Thu, 19 Sep 2024 14:30:20 +0000

Se você é desenvolvedor ou está começando a programar, provavelmente já ouviu falar de Git e GitHub. Essas ferramentas são essenciais no mundo do desenvolvimento de software, especialmente para quem trabalha em equipe ou em projetos de código aberto. Mas o que são exatamente e por que são tão importantes?

O que é Git?

O Git é um sistema de controle de versão distribuído, criado por Linus Torvalds em 2005. Ele permite que desenvolvedores acompanhem o histórico de alterações no código, colaborem em diferentes funcionalidades e revertam mudanças quando necessário. O Git torna fácil trabalhar em equipe, já que cada desenvolvedor pode ter sua cópia local do repositório e integrar suas contribuições ao projeto principal de maneira controlada.
O controle de versão também é extremamente útil para manter o histórico do projeto, possibilitando que você "volte no tempo" e veja como o código evoluiu, ou mesmo retorne a um estado anterior caso algo não esteja funcionando como esperado.

O que é GitHub?

O GitHub é uma plataforma online que hospeda repositórios Git. Ele adiciona uma interface amigável e várias funcionalidades extras para colaborar com outros desenvolvedores. Além de armazenar repositórios, o GitHub oferece ferramentas como pull requests, issues e projetos, que facilitam a gestão de colaborações e o acompanhamento de bugs e novas funcionalidades.
Outro ponto importante é que o GitHub se tornou uma das principais plataformas para o desenvolvimento de código aberto, permitindo que desenvolvedores do mundo todo colaborem em uma enorme variedade de projetos.
Com Git e GitHub, você não só tem uma maneira poderosa de gerenciar o código localmente, mas também um espaço para compartilhar seu trabalho e colaborar globalmente.

Como criar um repositório no GitHub:

1. Acesse o GitHub: Entre na sua conta GitHub. Se você não tiver uma conta, crie uma em github.com.

2. Crie um novo Repositório:

No canto superior direito da tela, clique no ícone "+" e depois em New repository.
Preencha as informações do repositório:
- Repository name: Dê um nome ao seu repositório (por exemplo, "meu-projeto").
- Description (opcional): Adicione uma breve descrição do projeto.
- Escolha se quer o repositório Público ou Privado.
Você pode marcar a opção para adicionar um arquivo README se quiser que o repositório tenha uma descrição inicial, além de servir como arquivo para anotar demandas.

3. Crie o Repositório:

Após preencher as informações, clique em Create repository.
O GitHub irá criar o repositório e mostrar a URL do repositório, que você usará para clonar no seu Visual Studio.

Clonando o repositório no visual studio

Agora que você criou o repositório no GitHub, pode cloná-lo para sua máquina local e começar a trabalhar nele.
Passos para clonar um repositório no terminal do Visual Studio:

Abra o Visual Studio:
Abra o Terminal Integrado:
Navegue até a Pasta Desejada:
Use o Comando git clone:
No GitHub, copie a URL do seu repositório (HTTPS ou SSH).
No terminal do Visual Studio, digite o seguinte comando:

git clone <url_do_repositorio>

5.Resultado:

O Git irá clonar o repositório para a pasta atual, e você verá algo assim no terminal:

Cloning into 'meu-projeto'...
remote: Counting objects: 100, done.
remote: Compressing objects: 100% (XXX/XXX), done.
Receiving objects: 100% (XXX/XXX), done.

6.Acesse o Repositório Clonado:

Agora, navegue para a pasta do repositório clonado

cd meu-projeto

PRONTO, VOCÊ ESTÁ PRONTO PARA COMEÇAR!

Obs: Caso você não tenha configurado o Git na sua máquina previamente, não será possível clonar o repositório com sucesso. Antes de tentar o comando git clone, certifique-se de configurar o Git usando os seguintes comandos no terminal:

git config --global user.name "Seu Nome"
git config --global user.email "seuemail@exemplo.com"

Esses comandos configuram o nome de usuário e o e-mail globalmente no seu ambiente Git, informações que serão usadas ao fazer commits. Se o Git não estiver configurado, você poderá enfrentar erros ao tentar interagir com repositórios.

Mãos a massa!

Agora que você já clonou seu repositório, vamos criar um arquivo, adicionar ao controle de versão e explorar os comandos essenciais do Git.

Criando um Arquivo e usando comandos básicos

1. Criar um arquivo:

No Visual Studio, crie um novo arquivo na raiz do seu projeto, por exemplo, um arquivo chamado index.html. No terminal, você pode fazer isso com o comando:

touch index.html

Ou simplesmente crie o arquivo no próprio editor do Visual Studio.

2. Verificar o Status do Repositório:

Para ver o que mudou no seu repositório, use o comando git status:

Untracked files:
  (use "git add <file>..." to include in what will be committed)
      index.html

Isso significa que o Git detectou o arquivo index.html, mas ainda não está rastreando-o.

Comando `git add`

3. Adicionar Arquivos ao Controle de Versão:

Para começar a rastrear as mudanças em um arquivo, use o comando git add:

git add index.html

Se você quiser adicionar todos os arquivos modificados ou criados, pode usar:

git add .

Agora, os arquivos estão prontos para serem commitados.

Comando `git commit`

4. Fazendo um Commit:

Um commit grava as alterações no repositório. Para criar um commit, use o comando:

git commit -m "Adiciona arquivo index.html"

obs: A flag -m permite adicionar uma mensagem descritiva para o commit.

Comando `git log`

5. Verificar o Histórico de Commits:

Para ver o histórico dos commits feitos no repositório, use o comando git log:

git log

Essa é a opção padrão do log, mas o Git oferece algumas opções úteis que você pode usar para simplificar e personalizar a saída do git log.

Usando git log --oneline
-O modo oneline compacta a exibição dos commits em uma única linha por commit, mostrando apenas o hash curto e a mensagem do commit.
Comando:

git log --oneline

Usando git log --graph

O comando git log --graph exibe os commits em formato de gráfico, permitindo que você visualize visualmente a estrutura de branches e merges. Comando:

git log --graph

Combinando git log --graph --oneline --all

Você pode combinar várias opções para uma visualização mais completa e simples do histórico de commits. A combinação de --graph, --oneline, e --all (que mostra commits de todas as branches - você pode saber mais sobre brancher aqui) é particularmente útil para uma visualização clara da história do projeto.

Comando:

git log --graph --oneline --all

Saída (exemplo):

* a1b2c3d (HEAD -> master) Adiciona nova funcionalidade
| * 9e8f7g6 (feature) Corrige erro na branch feature
|/
* 5h4i3j2 Refatora código para melhorias

Comando `git checkout`

Esse comando serve para diversas ocasiões, mas irei abordar apenas duas:

6. Reverter Alterações:
Se você fizer alterações em um arquivo e quiser voltar para o último estado commitado, use o comando git checkout:

git checkout index.html

Isso desfaz as mudanças feitas em index.html que ainda não foram commitadas.

7. Vê como estava o projeto commit x:

Você pode usar o comando git checkout para "olhar" como estava o projeto em um determinado commit:

git checkout [nº commit]

Enviando e Atualizando o Repositório Remoto

Agora que você fez mudanças locais, pode querer enviar essas alterações para o repositório remoto (GitHub) ou trazer as alterações mais recentes que alguém fez no repositório.

Comando `git pull`

8. Atualizando o Repositório Local:

Antes de enviar suas alterações, é uma boa prática garantir que sua cópia local está atualizada com o repositório remoto. Para isso, use:

git pull

O git pull traz as mudanças do repositório remoto para a sua máquina local.

Comando `git push`

9. Enviando Suas Alterações para o Repositório Remoto:

Agora, você pode enviar seus commits locais para o GitHub com o comando git push:

git push

Isso enviará suas alterações para a branch master ou main no repositório remoto.

Forem: Joel Hanerth

Initial introduction to Git and github

What is Git?

What is GitHub?

How to create a repository on GitHub:

Cloning the repository in Visual Studio

Creating a File and Using Basic Commands

git add Command

git commit Command

git log Command

git checkout Command