Aprenda a usar o Github para aumentar suas oportunidades profissionais
Tags: git, github, mercadodetrabalho, portfólio
Published: 2021-11-30 21:09:32

Se torne um profissional bem visto e almejado aplicando essas dicas sobre Github.

George, Agatha, Jennifer e James estudam computação. George faz todos os seus trabalhos bem feitos. Agatha realiza muito bem seus trabalhos e os hospeda no site de repositórios Github. Enquanto isso, Jennifer faz bons trabalhos, hospeda seus códigos no Github e, ainda, escreve boas descrições (README) em seus projetos, para mostrar que o projeto é interessante e bem feito. Por fim, James realiza bons trabalhos, hospeda no Github, monta bons READMEs e ainda utiliza boas práticas em seus códigos, geralmente indo além do que foi pedido e publica no LinkedIn para divulgar seus projetos.

A partir dessa história, qual dos quatro alunos parece ter maiores chances de conseguir estágios e empregos ao longo da vida? George que cria bons trabalhos, mas apenas o professor fica sabendo? Agatha que hospeda seus códigos no Github, mas não descreve seus trabalhos? Jennifer que escreve bons READMEs, mas não vai além do que foi pedido nem pensa em utilizar boas práticas ou o James que utiliza boas práticas em seus trabalhos, além de divulgá-los muito bem no Github e LinkedIn?

Obviamente, o mercado de trabalho não é exato e depende de cada processo seletivo, contudo as chances de George, mesmo sendo um ótimo aluno são menores que as chances dos outros alunos e é bem provável que as chances de James sejam as maiores.

Empresas de tecnologia vão olhar sites como LinkedIn, Github e outros sites para portfólio, como Pinterest, Dribble. Afinal, como a empresa saberá que você é um bom profissional? Um bom programador? Um bom designer? Vendo projetos que você já fez, mesmo em sua época de curso (técnico ou graduação).

## 1. O que é Git e Github

Antes de sabermos o que é Github, precisamos saber o que é **Git**. Mostrarei dois memes para você começar a entender.

![Meme sobre Git e como voltar a um código anterior](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c4lkgz80az8tl3xprwf4.jpg)

![Meme sobre um motivo de usar Git](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/puo49gwn7ez6u4ekg1a0.jpg)

Agora contarei uma história para isso.

Você está desenvolvendo um código e precisa enviar o código ao seu colega, como você faz? Envia o código pelo email? E se atualizar o código? Envia novamente e novamente?
E se você alterar o código e alguma coisa parar de funcionar (um novo bug)? Como você volta a versão que funcionava? Agora imagine esses problemas em uma equipe, você trabalha com mais três pessoas, como a alteração de um será enviada aos outros? 
Para resolver esses e outros problemas, foram criados os **Sistemas de Controle de Versão**. Um dos primeiros era o SVN, porém era muito ruim, era centralizado, então novos sistemas foram criados, como o Mercurial e o Git, esse último criado pelo Linus Torvalds, criador do Linux. Os atuais são **Sistemas de Controle de Versões Distribuído*, pois permitem códigos distribuidos por diversos repositórios. Atualmente o Git é o mais famoso.

> Sistema de controle de versão gerência diversos aspectos referentes aos códigos, não apenas alterações.

## 2. E o Github, o que é?

Esses sistemas servem para controlar as versões de códigos, mas onde ficam os códigos? Os códigos são armazenados em repositórios de códigos. Esses repositórios podem estar na sua máquina ou em uma máquina remota, na internet, aí entra o Github. Ele é um site de repositórios de códigos, cada repositório é para um projeto ou parte de um. 

## 3. Como o Git e Github funcionam

Básicamente ao usar o Git você segue os seguintes passos, a Figura abaixo apresenta de forma visual:
1. Inicia um repositório local (na sua máquina) para armazenar o código e gerenciar os códigos;
2. Indica qual será o repositório remoto, opcional, mas muito usado;
3. Realiza alterações no código;
4. Registra as alterações no código;
5. Gera e registra uma mensagem (*commit*) com essas alterações realizadas no repositório local;
6. Envia esse *commit* para os demais repositórios, como o repositório remoto (opcional);
7. Repete os passos do 3 ao 5 ou 6 até que o *software* morra (pare de ser atualizado).

![Git - Fluxo simplificado](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cmo30gmx6yf3qoxcysel.png)

O repositório remoto geralmente é criado no Github, podendo ser criado no bitbucket, gitlab ou outro servidor Git. No Github você tem uma interface para visualizar o repositório, inclusive a descrição do repositório, como o README.md, um arquivo contendo informações sobre o repositório.
Agora que você sabe um pouco do funcionamento, vamos detalhar tudo isso abaixo.

## 4. Instalando o Git em seu computador

O Git é um programa que costuma ser usado via terminal (linha de comando), o famoso prompt de comando do Windows, porém também existem interfaces gráficas para ele, contudo já aviso que 99% dos desenvolvedores usam o Git por linha de comando, inclusive a maior parte dos desenvolvedores usam distribuições Linux (Sistema Operacional que usa o Kernel Linux), pois é muito mais fácil configurar o ambiente de trabalho nesse sistema. O MacOS é outro sistema fantástico para desenvolvedores, pois une o melhor do Linux com a facilidade gráfica do Windows.

### 4.1. Git no Windows
Assim, para instalar o Git no Windows temos algumas opções, normalmente é simples baixar e instalar:
- [Git for Windows](https://gitforwindows.org/)
- [Git SCM](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)

Caso queira também interface gráfica, temos algumas opções, dentre elas as mais famosas são:
- [GitHub Desktop](https://desktop.github.com/)
- [GitKraken](https://www.gitkraken.com/)

### 4.2. Git no Linux

Instalação do Git no Linux geralmente é muito simples, inclusive algumas distribuições já contam com o Git instalado, mas caso não seja o seu caso basta ir no terminal e realizar a instalação do pacote git, algo como:

```bash
apt install git # distribuições baseadas em Debian
```

```bash
pacman -S git # distribuições baseadas em Arch Linux
```

## 5. Criando uma conta no Github

Criar uma conta no Github é bastante fácil, acesse o site [github.com](https://github.com/) e verá uma página como esta abaixo.

![Github - Página inicial](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/390b5b4u3o38lw2mkyo8.png)
 
Vá em `Sign up` (criar conta) e preencha seus dados, normalmente basta um e-mail, senha e nome de usuário, o nome de usuário é importante, crie um nome que reflita seu nome, o meu é ArthurAssuncao, então para acessar o meu perfil no Github basta acessar o [Github.com/ArthurAssuncao](https://github.com/ArthurAssuncao).

![Github - Página de cadastro de usuário](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wmsgmaglryegzjjdqllk.png)

> *Sign up* e *Sign in* são termos muito parecidos que tem significados diferentes, mas podem causar engano, principalmente em pessoas que não são de TI, cuidado ao usar esses termos em seu site, eu prefiro Register/Cadastro/Cadastre-se e Log in/Login/Logar/Entrar e variações desses termos. 
 
## 6. Criando um repositório no Github

Abra a página do [Github](https://github.com/) e faça seu login (`Sign in`).

![Github - Página de login](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dmwlabucdf68k90q6f97.png)

Agora você está na página do seu perfil, clique no sinal de soma (+) no canto superior direito e clique em `New repository`.

![Github - Criação de repositório](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d7vi46o6ipfoe08l88j0.png)

Agora você deve informar algumas informações sobre o novo repositório para que ele seja criado, são elas:

- **_Repository name_**: Indique o nome do seu repositório, o nome gerado não terá espaços nem acentos, portanto aconselho usar apenas letras, números e traço. Coloque o nome do projeto que você irá criar.
- **_Description_**: Descreva em poucas palavras sobre o que é este projeto/repositório.
- **_Public_** ou **_Private_**: Diz respeito a visibilidade do repositório. Um repositório público pode ser acessado por qualquer pessoa na internet, isso inclui todo o código, mídias (fotos, vídeos, PDFs etc) e todo histórico do repositório. Enquanto privado apenas você tem acesso. Prefira projetos públicos, exceto se realmente precisar de privacidade quanto aos dados do projeto. De toda forma, depois você pode alterar o projeto para público.
- **_Initialize this repository with_**: Aqui temos algumas opções para indicar no seu projeto, temos:
  - **_Add a README file_**: `README` é um arquivo escrito em linguagem `Markdown` (é bem simples, mais para frente explico um pouco) e neste arquivo ficam informações sobre o projeto. Este é um arquivo muito importante para divulgar o seu repositório/projeto. Marque se quiser que o repositório já inicie com um `README`, mas depois você pode criá-lo.
  - **_Add .gitignore_**: .Gitignore é um arquivo que indica arquivos e pastas/diretórios que não serão armazenados nos repositórios do projeto, sabe aquele arquivo com dados sensíveis do servidor? Você indica esse arquivo no `.gitignore` para que ele seja ignorado, portanto salve o arquivo sensível em outro lugar, como o seu e-mail. Você também pode criar este arquivo depois, mas sugiro fortemente que já inicie o projeto com este arquivo.
  - **_Choose a license_**: Escolher uma licença de software para o seu projeto, geralmente são licenças de software livre, desde as mais permissívas, como a `Do What The F*ck You Want To Public License` até licenças que forçam qualquer código copiado a ser também *open-source*, como a *GNU General Public License v3.0*. Se o projeto for privado, use a licença `UNLICENSED`. Eu costumo usar a licença `MIT`. Leia mais sobre licenças em [Open-Source Licenses by Nicolas Dao](https://gist.github.com/nicolasdao/a7adda51f2f185e8d2700e1573d8a633) ou veja mais sobre quase todas existentes em [SPDX Licenses](https://spdx.org/licenses/).

![Github - Criação de repositório](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p7l7x7oewlid546yc92o.png)
 
Você irá ser apresentado a página do novo repositório, como esta abaixo que criei para o repositório de nome `teste-palestra`.

![Github - Página do repositório recentemente criado](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/b165zstnfdtef10paxv8.png)
 
Nesta página você percebe diversas coisas, há como criar um novo arquivo ou fazer upload de um arquivo, mas não use essas opções, vamos fazer por linha de comando.
E três tutoriais com comandos para enviar códigos ao repositório, o primeiro `…or create a new repository on the command line` tem o foco em um projeto que será desenvolvido, o segundo `…or push an existing repository from the command line` para projetos que já existem no seu computador e o terceiro `…or import code from another repository` para importar projetos de outros Sistema de Controle de Versão.
Não faça nada por enquanto, vamos fazer isso na próxima seção.

## 7. Fazendo seu primeiro commit repositório

Nosso repositório está vazio. Vamos fazer tudo do nosso computador.
Abra o prompt de comando ou shell ou bash ou terminal ou power shell ou outro programa semelhante, como esse abaixo:

![Terminal do Linux com Oh My Zsh e tema agnoster](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9jilb3ehr1lnvri1mzpq.png)

Digite `mkdir teste-palestra` e aperte `enter`, isso criará o diretório `teste-palestra`.
Agora digite `cd teste-palestra/`, com este comando vamos entrar na pasta `teste-palestra` pelo nosso terminal.
Então abra um editor de código ou texto de sua preferência, como o Notepad/Bloco de notas ou o VSCode. Digite dentro do arquivo o texto abaixo:

```
## Teste Palestra

Projeto para a palestra sobre Github
```

Por fim, salve o arquivo com o nome `README.md` e o salve dentro da pasta `teste-palestra`.
Você acabou de criar um arquivo em `Markdown`, ainda nesse texto vou explicar melhor essa linguagem.

![Terminal - Comandos mkdir e cd](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8qpwuaghivqcai5fct2h.png)

### 7.1. Configurando o Git na sua máquina

Antes de tudo vamos configurar o Git, esses passos serão feitos apenas uma vez, pois ficam configurados na sua máquina, assim só os repita caso mude de computador ou se reinstalar o Git. Execute os comandos em seu terminal, como a figura abaixo. Além disso, substitua os meus dados pelos seus dados. 
O primeiro irá definir o usuário padrão da máquina como o usuário indicado e o segundo informa o e-mail do usuário padrão.
Enquanto o terceiro comando informa que as credenciais, senha e usuário, podem ser armazenados no computador. Só use essa opção se estiver usando o seu computador, mas fique tranquilo que ele não irá armazenar sua senha no computador, apenas na memória RAM, de forma segura. Por fim, o quarto comando informa o tempo de armazenamento dessas credenciais, por padrão o tempo é 900 segundos, ou seja, 15 minutos, porém recomendo aumentar para 3600, assim ele armazenará seu usuário e senha (token) por uma hora, isso significa que você não irá precisar digitar novamente essas informações caso faça um novo `pull` ou `push`.

```
git config --global user.name "ArthurAssuncao"
```

```
git config --global user.email "meuemail@arthurassuncao.com"
```

```
git config --global credential.helper store
```

```
git config credential.helper 'cache --timeout=3600'
```

![Git - Comandos de configuração de usuário](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j96br4obynwjgz5yqk8p.png)

### 7.2. Usando os comandos Git

O primeiro comando não-configurável que você precisa conhecer é o comando `git init`, este comando inicia um repositório local Git na pasta/diretório onde for executado. Saiba que poderíamos ter usado esse comando antes de criar o arquivo `README.md`, mas não muda nada. Apenas saiba que esse comando só é usado uma vez, pois ele inicia o repositório local na sua máquina, você só executaria novamente se replicasse o repositório em outro diretório ou outro computador.
Então execute:

```
git init
```

Você irá receber a mensagem semelhante a esta abaixo dizendo que o repositório foi inicializado.

```
Initialized empty Git repository in /home/arthur/teste-palestra/.git/
```

Agora vamos ver quais foram as nossas modificações no repositório usando o comando `git status`, como acabamos de criar um repositório vazio, o nosso arquivo `README.md` será considerado um arquivo novo, ou seja, uma alteração no repositório. Digite o comando e tecle enter.

```
git status
```

A saída mostrada no terminal será esta abaixo, perceba que ele deixa claro que o arquivo `README.md` é um arquivo novo (untracked) e recomenda que usemos `git add <file>` para incluir ele em um `commit`.

```
On branch main

No commits yet

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

nothing added to commit but untracked files present (use "git add" to track)
```

Então vamos adicionar o arquivo `README.md` para nosso futuro `commit`, mas, antes, o que é um `commit`?

Um `commit` é um pacote com uma mensagem e outras informações que indica as alterações realizadas. Antes do `commit` nós temos o `stage` que é um `"commit" temporário`.
Agora que você já sabe, vamos adicionar o arquivo ao `Stage` que será nosso futuro `commit`. Para isso use o comando `git add README.md`, você também pode usar a opção `git add .`, nesse caso adicionaria todos arquivos novos e alterados e não apenas o arquivo indicado.

```
git add README.md
```

### 7.3. Realizando o *commit*

Com arquivos adicionados em nosso `staging`, vamos criar um `commit`, para isso use o comando abaixo, perceba que passamos uma mensagem para ele, pois é uma forma visual de sabermos quais alterações foram realizadas.

```
git commit -m "first commit"
```

A saída será algo como esta abaixo, indicando que um novo arquivo README.md foi criado com um arquivo alterado e três linhas inseridas.

```
[main (root-commit) 4e3ec95] first commit
 1 file changed, 3 insertions(+)
 create mode 100644 README.md
```

As mensagem de `commit` podem seguir padrões, um muito recomendado é o [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/), usá-lo pode te ajudar a mostrar que é um bom desenvolvedor.

### 7.4. Boas práticas ao criar *commits*

Além do uso do **Conventional Commits** recomendo que crie pequenos `commits`, o que seria isso? A cada alteração em seu código, como uma nova funcionalidade ou nova configuração, faça um `commit`, não espere terminar todo o projeto para fazer um commit com milhares de alterações, pois isso é mal visto uma vez que não é assim que se faz no mercado de trabalho.

### 7.5. Criando uma ligação entre o Github e seu computador

Para criarmos uma ligação entre o repositório remoto no Github e o repositório local em seu computador, vamos configurar um `remote`, execute a linha abaixo, perceba o nome do projeto e o nome do usuário, portanto não copie, adapte ao seu contexto ou simplesmente copie a linha parecida com essa do tópico **7. Criando um repositório no Github**.
Neste comando vamos adicionar o nome `origin` como uma referência ao repositório remoto, é tipo um *link*.

```
git remote add origin https://github.com/ArthurAssuncao/teste-palestra.git
```

### 7.6. Enviando o *commit* ao repositório remoto no Github

Para enviarmos o nosso `commit` com nosso código e demais informações ao Github devemos usar o comando `git push`, no primeiro uso faça como na linha abaixo, indicando o `-u`, nas próximas vezes não precisará desse `-u`.
No comando, o `origin` indica o repositório remoto, aquele que configuramos acima e o `main` indica a `branch` que receberá o código. Não se preocupe com o conceito de `branch` agora, mas sugiro fortemente que aprenda sobre organização de um repositório com uso de `branchs`.

```
git push -u origin main
```

Será pedido que digite o seu usuário, em seguida pedirá para digitar a sua senha.

A saída será um erro, como este abaixo:

```
Username for 'https://github.com': ArthurAssuncao
Password for 'https://ArthurAssuncao@github.com': 
remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead.
remote: Please see https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/ for more information.
fatal: Authentication failed for 'https://github.com/ArthurAssuncao/teste-palestra.git/'
```

Isso acontece, pois em agosto de 2021 o suporte a senha foi descontinuado por questões de segurança, agora precisamos configurar um *Access Token*, vamos então fazer isso para enviarmos o `commit`.

### 7.7. Criando um *Access Token*

Volte ao site [Github.com](https://github.com/) e vá em `Settings` acessando o menu no canto superior direito ou acesse direto a página de configurações em [https://github.com/settings/profile](https://github.com/settings/profile). Acesse `Developer settings`, abrirá uma página como essa abaixo:

![Github - Configuração de Token](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4zwb4gx94kjk6k7r31vd.png)

Agora clique em `Personal access tokens` e em `Generate new token`, abrirá uma nova tela, como essa abaixo:

![Github - Página New personal access token](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j49dojwcvbk21fx04wsk.png)

No campo `Note` escreva o nome dele, como meu-computador. Em `Expiration` coloque o tempo que queira que esse token expire, pode ser `No expiration`, então ele nunca irá ser removido.
Agora marque todas opções em `Select scopes`.
Pronto agora você terá um token que é um texto com vários caracteres sem qualquer sentido. Token é como uma senha, não compartilhe com ninguém.

### 7.8. Enviando o *commit* com Access Token

Agora vamos repetir os passos do item 8.6. Enviando o *commit* ao repositório remoto no Github. Execute o comando abaixo:

```
git push -u origin main
```

Será pedido que digite o seu usuário, em seguida pedirá a senha, mas digite o token (pode copiar e colar no terminal) no lugar da senha. Pronto, o código será enviado e a saída será como esta da figura abaixo.

![Github - Envio de commit com access token](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4t19c0v76ao4mex3q1lx.png)

### 7.9. Nosso repositório no Github

Vamos ao nosso projeto no github, aquele que você criou, atualize a página e ele estará como na figura abaixo.

![Github - Projeto com um commit](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8whoc8s2z0t1quzw6qsz.png)

## 8. Comandos mais comuns do Git

- **git add <file>**: adiciona um arquivo ao staging.
- **git commit -m "mensagem"**: cria um `commit`.
- **git push origin main**: envia os `commits` criados para o `origin` na branch `main`.
- **git pull origin main**: faz o download das alterações com base no repositório `origin` e sua *branch* `main`. Ótimo para quando se quer baixar as atualizações que estão no repositório remoto, mas que ainda não estão na sua máquina.
- **git status**: verifica os arquivos novos e alterados do repositório local.
- **git diff**: verifica as alterações realizadas, aqui são mostradas as alterações dentro dos arquivos.
- **git log**: mostra o `log` de commits já realizados.

## 9. Deixe seu repositório mais atraente

Sempre que criar um projeto hospede no Github, faça muitos commits, quantos forem necessários, nada de apenas um commit.

Além disso, inclua no README de seus projetos:
- Logo do projeto (crie logos mesmo que simples);
- Nome do projeto (sempre dê um nome);
- Indique tecnologias usadas com `badges`;
- Coloque um link para acesso ao projeto online, caso possível;
- Insira _screenshots_ do projeto, animações em GIF podem ser muito interessantes;
- Coloque um índice, caso o texto fique extenso;
- Tópicos
  - O que o projeto faz?
  - Se for um projeto de um curso, o que você fez para torná-lo melhor, mais único?
  - Quais tecnologias usou? Onde e por quê cada tecnologia foi utilizada?
  - Mais _layouts_, se for necessário.
  - Aprendizado com o projeto (caso você não tenha muita experiência)
  - Como executar o projeto?
  - Licença do projeto.

Veja alguns exemplos:
- [Projeto PomoTraining](https://github.com/ArthurAssuncao/pomoTraining)
- [Projeto Landing Page do Trainrail Hackathon Brasil](https://github.com/ArthurAssuncao/TrainRailHackathonBrasil.com.br)

## 10. Deixe seu perfil no Github mais chamativo

Para deixar o seu perfil mais interessante crie um `README` para ele, estilo o Sobre do LinkedIn, além disso indique seus melhores projetos para facilitar o trabalho de Recrutadores Técnicos.

### 10.1. Criar README para seu perfil
Para isso:
1. Crie um repositório com o mesmo nome do seu usuário. Meu usuário é ArthurAssuncao, então criei um repositório chamado ArthurAssuncao.
2. Adicione um arquivo `README.md` e edite colocando:
- Informações de contato e link para currículo e LinkedIn no topo;
- Texto sobre você, especifique as tecnologias/linguagens que você usa;
- Coloque o que você faz;
- Suas últimas experiências;
- Descreva seus aprendizados;
- Seja bem técnico, pois quem irá ler será alguém mais técnico, possivelmente até outro desenvolvedor.

O meu está como mostram as figuras abaixo:

![Github - Exemplo README Perfil parte 1](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/h3qmhhntir4vyq6kqf5q.png)

![Github - Exemplo README Perfil parte 2](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/oyfidcgy4zsv4poat5hm.png)

![Github - Exemplo README Perfil parte 3](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ryb46270lxde620bpg3d.png)
  

## 11. Ideias para projetos

Para tornar o seu Github mais interessante mesmo sem ter experiência profissional basta criar projetos, assim você mostra que sabe.

Tipos de projetos para mostrar?
- Clone perfil de rede social: use HTML, CSS, JavaScript e outras tecnologias;
- Copie o layout de algum site conhecido: use HTML, CSS, JavaScript e outras tecnologias;
- Monte um Jogo da velha: use HTML, CSS, JavaScript e outras tecnologias;
- Crie seu site pessoal/portfólio: use HTML, CSS, JavaScript e outras tecnologias;
- Monte compoenntes como pequenos códigos (snippets) com animações, eventos e outras funções chamativas.

## 12. Markdown

Markdown é uma linguagem muito simples para marcação e formatação de textos, sabe quando você coloca negrito ou itálico no whatsapp e usa asterisco ou til? O markdown é semelhante a isso, por isso a sua simplicidade.

As formatações do markdown são:

| Tipo | Sintaxe | Resultado |
| ----------- |  ----------- | ----------- | 
| Título 1 | `# Seu título` | .. | 
| Título 2 | `## Seu título` | .. | 
| Título 3 | `### Seu título` | .. | 
| Título 4 | `#### Seu título` | .. | 
| Título 5 | `##### Seu título` | .. | 
| Título 6 | `###### Seu título` | .. | 
| Título 6 | `###### Seu título` | .. | 
| Itálico | `*texto*` ou `_texto_` | *texto* |
| Negrito | `**texto**` ou `__texto__` | **texto** |
| Riscado | `~~texto~~` | ~~texto~~ |
| Bloco de citação | `> citação` | > citação |
| Lista ordenada | `1. item` | 1. item |
| Lista não ordenada | `- item` | - item |
| Código inline | \`texto\` | `texto` |
| Link | `[nome link](https://www.example.com)` | [nome link](https://www.example.com) |
| Imagem | `![descrição](https://avatars.githubusercontent.com/u/583231)` | ![descrição](https://avatars.githubusercontent.com/u/583231?v=4) |
| Tabela | apresento abaixo | .. |
| Bloco de código | apresento abaixo | .. |

Abaixo apresento mais algumas formatações, ainda detalho melhor algumas e mostro como ficam. Se quiser ver todas formatações possíveis acesse [Markdown Cheat Sheet](https://www.markdownguide.org/cheat-sheet/).
**A. Título de nível 1**
Adicione `#` antes do título e ele será um título de nível 1, seria como o título maior do texto.
Abaixo apresento o código e em seguida como ele fica.
```
# Seu Título
```

# Seu Título

**B. Título de nível 2**
Adicione `##` antes do título e ele será um título de nível 2.
Abaixo apresento o código e em seguida como ele fica.
```
## Seu Título
```

## Seu Título

**C. Título de nível 3**
Adicione `###` antes do título e ele será um título de nível 3.
Abaixo apresento o código e em seguida como ele fica.
```
### Seu Título
```

### Seu Título

**D. Título de nível 4**
Adicione `####` antes do título e ele será um título de nível 4.
Abaixo apresento o código e em seguida como ele fica.
```
#### Seu Título
```

#### Seu Título

**E. Título de nível 5**
Adicione `#####` antes do título e ele será um título de nível 5.
Abaixo apresento o código e em seguida como ele fica.
```
##### Seu Título
```

##### Seu Título

**F. Título de nível 6**
Adicione `######` antes do título e ele será um título de nível 6.
Abaixo apresento o código e em seguida como ele fica.
```
###### Seu Título
```

###### Seu Título

**G. Lista ordenada**
Para fazer uma lista ordenada basta usar números com ponto.
```
1. Item 1
2. Item 2
3. Item 3
```

1. Item 1
2. Item 2
3. Item 3

**H. Lista não ordenada**
Para fazer uma lista não ordenada basta iniciar os itens com traço (`-`) ou asterisco (`*`).
```
- Item 1
- Item 2
- Item 3

* Item 1
* Item 2
* Item 3
```

- Item 1
- Item 2
- Item 3


* Item 1
* Item 2
* Item 3

**I. Tabela**

Tabela é um pouco mais complicado, veja a sintaxe abaixo.
```
| Nome | Descrição |
| ----------- | ----------- |
| Whatsapp | Aplicativo para troca de mensagens |
| Instagram | Rede social para compartilhamento de fotos e vídeos |
| LinkedIn | Rede social para contatos profissionais |
| Github | Repositório e rede social de códigos |
```

| Nome | Descrição |
| ----------- | ----------- |
| Whatsapp | Aplicativo para troca de mensagens |
| Instagram | Rede social para compartilhamento de fotos e vídeos |
| LinkedIn | Rede social para contatos profissionais |
| Github | Repositório e rede social de códigos |

**J. Bloco de código**
Se quiser apresentar um bloco de código basta fazer como mostra abaixo:

![Markdown - bloco de código](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nnywo4xpjwhz4qltqcmr.png)
 
```javascript
{
  "nome": "Github",
  "descricao": "Repositório e rede social de códigos",
}
```

## 13. Ao infinito e além...

Agora que você já sabe um pouco de Git e Github, vamos pensar em como melhorar nossas práticas? Seguem algumas dicas do que procurar aprender.

1. Aprenda como utilizar SSH com chave pública para não precisar digitar o `Access Token` ao realizar uma ação no Github pelo terminal.
2. Aprenda sobre `Pull Requests` e `Branchs`.
3. Aprenda a manipular as branchs de um repositório. Normalmente fazemos `commits` em uma branch de desenvolvimento, fazemos Pull Requests para a branch `main` e realizamos um `Code Review` (revisão do código para encontrar erros ou falta de padrões).
4. Treine bastante e "commite" muito.

## Referências

A STEP-BY-STEP guide to Git. Disponível em: [https://opensource.com/article/18/1/step-step-guide-git](https://opensource.com/article/18/1/step-step-guide-git). Acesso em: 28 nov. 2021.
GIT CHEAT Sheets. Disponível em: [https://training.github.com/](https://training.github.com/). Acesso em: 28 nov. 2021.
GIT DOWNLOADS. Disponível em: [https://git-scm.com/downloads](https://git-scm.com/downloads). Acesso em: 28 nov. 2021.
GIT FOR Windows. Disponível em: [https://gitforwindows.org/](https://gitforwindows.org/). Acesso em: 28 nov. 2021.
GIT GUIDES. Disponível em: [https://github.com/git-guides](https://github.com/git-guides). Acesso em: 28 nov. 2021.
GITHUB Git Cheatsheet. Disponível em: [https://training.github.com/downloads/pt_BR/github-git-cheat-sheet.pdf](https://training.github.com/downloads/pt_BR/github-git-cheat-sheet.pdf). Acesso em: 28 nov. 2021.
MARKDOWN Cheat Sheet. Disponível em: [https://www.markdownguide.org/cheat-sheet/](https://www.markdownguide.org/cheat-sheet/). Acesso em: 28 nov. 2021.