GERÊNCIA E QUALIDADE DE SOFTWARE_sem1

Prévia do material em texto

GERÊNCIA E QUALIDADE DE SOFTWARE (COM 480) 
 
Apresentação e versionamento de software 
 
Olá, estudante! 
Nesta semana, começaremos os estudos da disciplina Gerência e Qualidade de Software, que tem como 
objetivo “conhecer e aplicar os conceitos práticos relacionados à qualidade de software e as diferentes 
métricas para a sua avaliação”. 
Para isso, cobriremos vários tópicos que, direta ou indiretamente, levam os desenvolvedores de software a 
produzir software com melhor qualidade, seguindo métodos sistemáticos de engenharia de software, sempre 
que possível com uma visão prática desses tópicos. Começaremos nesta semana com o tópico de 
versionamento de software, por meio da demonstração de uma ferramenta. 
Bom estudo para você! 
Objetivos de aprendizagem 
Ao final desta semana, você deverá ser capaz de: 
Objetivos de aprendizagem 
Ao final dessa semana, você deverá ser capaz de: 
• Conhecer os principais tópicos a serem cobertos na disciplina; 
• Conhecer o versionamento de software via o uso de uma ferramenta. 
 
Revisitando Conhecimentos 
Essa videoaula apresenta uma visão geral sobre a gestão de configuração e liberação de software, incluindo 
a sua importância e necessidade, assim como o momento de ela ser realizada dentro do processo de 
desenvolvimento de software, incluindo o uso de contêineres de software. 
 
Orientação de estudos 
Comece seus estudos assistindo à primeira videoaula que apresenta uma visão geral do que você estudará 
nesta disciplina, seguido pelo Texo-base, capítulo do livro do Pressman que cobre essa parte da engenharia 
de software. Na sequência, há duas videoaulas (2 e 3) que tratam do primeiro assunto coberto, que é 
versionamento de software com a ferramenta Git, e um capítulo de livro (Texto-base: Engenharia de 
Software Moderna), dedicado a apresentar conceitos relacionados ao uso de Git. 
 
Apresentação 
OBJETIVOS DA DISCIPLINA 
Conhecer e aplicar os conceitos práticos relacionados à qualidade de software e as diferentes métricas para a sua 
avaliação. 
EMENTA DA DISCIPLINA 
1. Controle avançado de versões com git. 
2. Ferramentas para gestão de dependências e compilação (como maven, gradle e cmake). 
3. Ferramentas para testes automatizados de unidade (como a família *Unit), aceitação e de integração (como 
cucumber). 
4. Cobertura de testes. 
5. Apresentação das formas de refatoração mais comuns. 
6. Integração contínua. 
7. Métricas de código-fonte. EMENTA DA DISCIPLINA 
8. Beleza de código (clean code). 
9. Programação pareada e revisão de código (code review). 
10. Dívida técnica. 
11. Noções de arquitetura de software e padrões arquiteturais. 
12. Geração automática de documentação. 
13. Comunicação com o usuário. 
CONTEÚDO SEMANAL 
SEMANA 1 – APRESENTAÇÃO E VERSIONAMENTO DE SOFTWARE: 
• Principais tópicos a serem cobertos na disciplina. 
• Versionamento de software via o uso de uma ferramenta. 
SEMANA 2 – COMPILAÇÃO E INTEGRAÇÃO AUTOMATIZADAS: 
• Automação de compilação e integração de software via o uso de uma ferramenta: 
➢ Ferramenta Maven. 
➢ Ferramenta Gradle. 
➢ Ferramenta CMake. 
SEMANA 3 – AUTOMAÇÃO DE TESTE DE SOFTWARE: 
• Automação de teste de unidade via o uso de uma ferramenta: 
➢ Ferramenta JUnit/XUnit. 
• Automação de teste de sistema/aceitação via o uso de uma ferramenta: 
➢ Ferramenta Selenium. 
➢ Ferramenta Cucumber. 
SEMANA 4 – ANÁLISE DE COBERTURA DE TESTE E REFATORAÇÃO: 
• Análise de cobertura de teste via o uso de ferramentas. 
• Principais tipos de refatoração de software. 
SEMANA 5 – INTEGRAÇÃO CONTÍNUA, MÉTRICAS E BELEZA DE CÓDIGO-FONTE: 
• Integração contínua via o uso de uma ferramenta. 
• Métricas de código-fonte de software. 
• Principais conceitos relacionados à beleza de código. 
SEMANA 6 – PROGRAMAÇÃO PAREADA, REVISÃO DE CÓDIGO E DÍVIDA TÉCNICA: 
• Principais conceitos relacionados à programação pareada. 
• Principais conceitos relacionados à revisão de código. 
• Principais conceitos relacionados à dívida técnica. 
SEMANA 7 – ARQUITETURA DE SOFTWARE, GERAÇÃO AUTOMÁTICA DE DOCUMENTAÇÃO E COMUNICAÇÃO COM O 
USUÁRIO: 
• Principais conceitos relacionados à arquitetura de software e padrões arquiteturais. 
• Geração automática de documentação via o uso de ferramenta. 
• Principais conceitos relacionados à comunicação com o usuário. 
 
PERGUNTA 1 
Um dos tópicos a ser coberto na disciplina de acordo com a sua ementa apresentada da videoaula é: 
o especificação de requisitos. 
o gestão de cronograma. 
o subcontratação de 
desenvolvimento. 
o dívida técnica. 
o treinamento de usuário. 
Você acertou! Essa é a alternativa correta. Dívida técnica é um dos tópicos a serem cobertos durante a disciplina. 
 
Versionamento com Git 
Visão geral 
Objetivos da aula 
Conhecer o versionamento de software via o uso de uma ferramenta (visão geral). 
 
Visão geral do Git 
Git: sistema de controle de versões (VCSs) 
• Software livre 
• Repositório de arquivos com controle de versões 
• Eficiente, além de outras características 
• Desenvolvido para Linux, mas possui versões para Windows 
• Outros VCSs: CVS, SVN, Mercurial, BitKeeper, Bazzar, Monotone 
 
 
Software com GUI para gerenciamento Git 
 
 
Websites para hospedagem em repositório Git na nuvem 
 
PERGUNTA 1 
Uma característica da ferramenta Git apresentada videoaula é: 
o ser um representante de sistemas chamados VCSs. 
o ter sido desenvolvido originalmente para Windows. 
o possuir várias vantagens, porém não é eficiente. 
o ser um software proprietário. 
o ser um repositório de arquivos com controle de versões. 
Você acertou! Essa é a alternativa correta. Git é um dos repositórios de arquivos com controle de versões mais 
usados na atualidade. 
 
Versionamento com Git Demonstrações 
Comandos git 
• Git init • Git merge • Git status 
• Git add • Git pull • Git branch 
• Git commit • Git push • Git clone 
PERGUNTA 1 
Um comando da ferramenta Git apresentado na videoaula é: 
o git remove. 
o git end. 
o git union. 
o git copy. 
o git push. 
Você acertou! Essa é a alternativa correta. Um comando apresentado e bastante importante é o “git push”. 
 
PERGUNTA 1 
Questão referente ao Texto-base - Engenharia de Software: Uma Abordagem Profissional (Leia o capítulo 22) | R. S. 
Pressman e B. R. Maxim 
O seguinte tópico ou conceito é discutido no capítulo 22 do livro de Pressman e Maxim: 
o integração contínua. 
o métodos ágeis. 
o orientação a objetos. 
o segurança da informação. 
o gestão de riscos. 
Você acertou! Essa é a alternativa correta. Integração contínua é um dos tópicos que compõem a gestão de 
configuração de software e que será a base para esta disciplina de Gerência e Qualidade de Software. 
 
ATIVIDADE AVALIATIVA 
PERGUNTA 1 
Qual comando da ferramenta Git é usado para criar snapshots (ou fotografias) dos arquivos de um sistema e 
armazená-las no sistema de controle de versões? 
o Push. 
 
o Commit. 
o Clone. 
o Pull. 
o Add. 
 
O comando “commit” é usado para criar e armazenar essas fotografias, as quais podem ser posteriormente 
recuperadas. 
 
PERGUNTA 2 
Qual comando da ferramenta Git é usado para atualizar um repositório local com as versões mais atualizadas (com 
commits) de um repositório remoto? 
o Push 
o Commit 
o Clone 
o Pull 
o Add 
 
 
 
O comando “pull” é usado para atualizar um repositório local com as versões mais atualizadas (com commits) de um 
repositório remoto. 
 
PERGUNTA 3 
Qual é o nome do comando que representa uma solicitação para que um desenvolvedor revise e, se for o caso, 
realize o merge de um branch que outro desenvolvedor criou? 
o add order. 
o merge request. 
o push order. 
o pull request. 
o clone suggestion. 
O comando “pull request” é usado para solicitar que um desenvolvedor revise e, se for o caso, realize o merge de um 
branchque outro desenvolvedor criou. 
PERGUNTA 4 
Qual comando da ferramenta Git é usado para copiar os commits mais recentes do repositório local para o repositório 
remoto? 
o Push. 
o Add. 
 
o Pull. 
o Commit. 
o Clone. 
O comando “push” é usado para copiar os commits mais recentes do repositório local para o repositório 
remoto. 
 
Aprofundando o tema 
Para aprofundar o tema, recomendo que você acesse o material a seguir: 
Material de apoio 1: Git - guia prático 
Material de apoio 2: Git & Github: O que é? Por quê? Como iniciar? 
Material de apoio 3: Git: o que é, para que serve e principais comandos Git! 
Material de apoio 4: Tutorial de Git e GitHub 
Material de apoio 5: Utilização do Git em ambiente Java com IDE Eclipse 
 
https://rogerdudler.github.io/git-guide/index.pt_BR.html
https://blog.rocketseat.com.br/iniciando-com-git-github/
https://blog.betrybe.com/git/
https://butecotecnologico.com.br/tutorial-git-e-github/
https://douglasgaspar.wordpress.com/2021/01/28/utilizacao-do-git-em-ambiente-java-com-ide-eclipse/
Git & Github: O que é? Por que? Como iniciar? 
 
Antes de falarmos de Git e Github vou descrever três histórias para iniciarmos com o entendimento 
de controle de versão: 
1. Você está trabalhando em um projeto com mais 3 desenvolvedores ao mesmo tempo e precisa repartir 
as novas funcionalidades do sistema com eles. Como você faz a junção do código ao final do 
desenvolvimento? (Lembrando que o mesmo arquivo pode ser editado por mais de um dev) 
2. Seu chefe pediu para você deletar uma funcionalidade do sistema que não é uti lizada. Após 3 meses ele 
decidiu que quer essa funcionalidade de volta. Como você faz para recuperar essa funcionalidade e 
implementá-la no projeto mesmo após muitas outras mudanças? 
3. Você é muito otimista e por isso não possui nenhum sistema de backup automático da sua aplicação 
em ambiente de desenvolvimento. Um belo dia seu computador queima e você não havia copiado suas 
últimas features para um pendrive. Como você faz para recuperar esse código? 
Se você é desenvolvedor e não sofreu com nenhum desses itens citados acima provavelmente você 
não é. Manter o código organizado entre o time, criar históricos de funcionalidades e backup em 
nuvem são alguns dos itens que o versionamento de código com Git & Github resolve. 
O que é Git? 
O Git é um sistema open-source de controle de versão utilizado pela grande maioria dos 
desenvolvedores atualmente. Com ele podemos criar todo histórico de alterações no código do nosso 
projeto e facilmente voltar para qualquer ponto para saber como o código estava naquela data. 
Além disso, o Git nos ajuda muito a controlar o fluxo de novas funcionalidades entre vários 
desenvolvedores no mesmo projeto com ferramentas para análise e resolução de conflitos quando o 
mesmo arquivo é editado por mais de uma pessoa em funcionalidades diferentes. 
Pontos na história 
Tudo no Git é movido através dos pontos na história do projeto que são chamados de commits, esses 
pontos são formados por conjuntos de alterações em um ou mais arquivos e somados a 
um descritivo que resume as alterações nesse ponto. 
De forma prática, pensando que tenhamos que desenvolver um sistema de login completo, 
nossos commits podem ficar dessa forma: 
1. Configuração da estrutura do projeto 
2. Estrutura da página de login 
3. Estilos CSS da página de login 
4. Estrutura da página de cadastro 
5. Resolvido problema no login 
6. Estilos CSS da página de cadastro 
Veja que nossos commits descrevem exatamente as alterações que o código sofreu e além do título 
podemos detalhar ainda mais com um texto maior. 
É muito importante essas informações estarem bem completas para que todos do time (inclusive 
você no futuro) possam entender o que foi feito nesse ponto. 
Ramificações 
Imagine que você esteja trabalhando no meio de uma grande funcionalidade, pode levar até 2 meses 
para terminá-la. Em uma bela manhã de sol seu chefe resolve pedir urgentemente uma alteração na 
versão em produção da aplicação, ou seja, você não pode utilizar o código em que está trabalhando 
pois o mesmo possui features inacabadas. Como resolver? 
As ramificações ou branchs no Git são formas de termos uma mesma versão do código sofrendo 
alterações e recebendo commits de diferentes fontes e inclusive por diferentes desenvolvedores. 
Dessa forma, nós podemos manter um ramo para nossa funcionalidade que irá levar mais tempo e 
trabalhar em outro branch com a versão em produção para realizar alterações mais urgentes. E fica 
tranquilo, no fim de tudo o Git ainda vai nos ajudar a unir os códigos desses dois ramos d e forma 
muito simpática. 
Por padrão, você sempre está trabalhando em um ramo no Git, e mesmo quando você não cria 
um branch, o Git cria automaticamente um branch chamado master como padrão. 
Na imagem abaixo podemos ver um exemplo de trabalho com vários ramos e commits aplicados. Veja 
que em alguns pontos da história os ramos são unidos para que as alterações de um ramo sejam 
aplicadas a outro. 
Foto de 
https://leanpub.com/git-flow/read 
Nesse caso, “master”, “Hotfix”, “Release”, “Develop” e os “Feature” são os ramos enquanto que os 
círculos são os commits. As caixas com v0.1, v0.2 e v1.0 são versões (conhecidas por tags) que foram 
pra versão em produção e podem ser compostas por pontos na história de vários branchs. 
Github 
Legal, até agora falamos sobre algumas funcionalidades do Git mas tem um grande problema aí: 
como os outros desenvolvedores do time terão acesso a todo esse código e poderão também 
adicionar seus branchs e commits? 
O Github é um serviço online de hospedagem de repositórios Git (como são chamados os projetos 
que utilizam Git). Com ele podemos manter todos nossos commits e ramos sincronizados entre os 
membros do time. 
Além de servir como hospedagem, o Github possui muitas integrações com serviços que auxiliam no 
deploy da aplicação através de integração contínua. 
Na prática 
Agora que já conhecemos os principais conceitos do Git e Github, vamos entender na prática como 
eles funcionam. Inicie fazendo download do Gitna sua máquina. 
Depois de instalado deve ser possível executar o comando git --versionno seu terminal para 
identificar se tudo ocorreu bem. 
Antes de continuar precisamos nos identificar no Git para que todos pontos na história tenham nossa 
assinatura. Execute os dois seguintes comandos com seu nome e e-mail respectivamente: 
git config --global user.name "Seu nome" 
git config --global user.email "seu-email@example.com" 
Agora, em uma pasta vazia vamos indicar que utilizaremos Git nesse projeto com o comando git 
init. Esse comando irá criar uma pasta oculta chamada .git no seu projeto onde ficarão 
armazenados todos os arquivos referentes à história do projeto. Se você deletar essa pasta, todo 
histórico é perdido. 
Você deve receber um retorno como esse: 
Initialized empty Git repository in C:/Users/SEU_USUARIO/projeto/.git/ 
Tudo pronto! Agora vamos criar nosso primeiro arquivo dentro dessa pasta. Abr a seu editor de 
preferência e crie um arquivo chamado arquivo.txt na raiz do diretório. 
Dentro desse arquivo, adicione o seguinte conteúdo: Primeira versão. De volta ao Terminal execute o 
comando git status, você deverá ter um retorno como o seguinte: 
On branch master 
 
https://blog.rocketseat.com.br/integracao-continua-ci-do-zero/
https://git-scm.com/downloads
No commits yet 
 
Untracked files: 
 (use "git add <file>..." to include in what will be committed) 
 
arquivo.txt 
 
nothing added to commit but untracked files present (use "git add" to track) 
O comando status exibe um relatório desde o último ponto na história e o que ele está nos dizendo 
agora é que estamos no branch master, não temos nenhum commit e temos um arquivo não 
rastreado pelo Git. 
Um arquivo não rastreado pelo Git quer dizer que não estamos controlando suas versões e o mesmo 
não entrará no próximo commit. Para começarmosa rastreá-lo, vamos executar o comando git add 
arquivo.txt. Após isso, podemos rodar o status novamente e teremos um retorno diferente: 
Changes to be committed: 
 (use "git rm --cached <file>..." to unstage) 
 
new file: arquivo.txt 
Agora podemos ver que o arquivo está em uma nova seção chamada “Alterações a serem comitadas”, 
ou seja, assim que criarmos um novo ponto na história, esse arquivo será adicionado a ele. 
Mesmo se você alterar esse arquivo novamente antes de criar o commit, você precisará dar 
um add nele novamente para que essas novas alterações sejam reconhecidas pelo Git. 
Agora com o arquivo adicionado, vamos criar nosso primeiro commit com o comando git commit -m 
"Primeira versão do projeto". Você receberá o seguinte retorno: 
[master (root-commit) 646845c] Primeira versão do projeto 
 1 file changed, 1 insertion(+) 
 create mode 100644 arquivo.txt 
Pronto, temos nosso primeiro ponto na história do projeto! 
O que é Git? 
Git é o sistema de controle de versão open source mais usado no mundo atualmente! Ele é usado 
para controlar o histórico de alterações de arquivos e principalmente de projetos de 
desenvolvimento de software. Ele permite mais flexibilidade no fluxo de trabalho, segurança e 
desempenho. 
O que é um sistema de controle de versão? 
Um sistema de controle de versão é uma ferramenta que ajuda equipes a gerenciar alterações 
em código fonte ao longo do tempo. Além disso, ele ajuda os times a trabalharem de forma mais 
rápida e inteligente. Isso acontece pois a ferramenta de controle de versão mantém um registro de 
todas as versões do código, ou seja, de todas as modificações. Isso ajuda a pessoa que desenvolve a 
conseguir voltar para qualquer versão anterior ou compará-las, ajudando a descobrir e corrigir erros 
muito mais rápido. 
Como surgiu o sistema de controle de versão Git? História! 
O Git foi desenvolvido pelo criador do kernel do Linux, Linus Torvalds, em 2005. Tudo começou 
com o rompimento de relações entre a comunidade que desenvolvia o kernel do Linux e a BitKeeper, 
que é um sistema de controle de versão que foi usado dentro do projeto do kernel. Com esse 
rompimento, a ferramenta do BitKeeper passou a ser paga. 
Com tudo isso, Linus Torvalds decidiu construir um sistema de controle de versão que tivesse 
a melhor performance e usou a experiência que teve com a BitKeeper para construir o Git, que se 
tornou o sistema de controle de versão mais utilizado no mundo. Linus tinha como principais metas 
para o seu projeto: 
• velocidade; 
• suporte para desenvolvimento na o-linear; 
• distribuí do; 
• lidar com projetos grandes de forma eficiente. 
Desde sua criação em 2005, o Git conseguiu amadurecer, tornar-se simples de usar e ainda manter 
esses pontos iniciais. 
Onde o Git pode ser usado? 
O Git pode ser usado em todo e qualquer projeto que tenha arquivos de diferentes tipos, podendo 
ser código, texto, imagens, vídeos, áudios, entre outros. O objetivo principal é permitir o controle de 
histórico e versão desses projetos, melhorar o trabalho em time e o fluxo de trabalho, proporcionar a 
segurança dos seus arquivos e outras tantas vantagens faladas nesse post. 
Quais as vantagens e desvantagens de usar Git? 
https://blog.betrybe.com/tecnologia/aprenda-tudo-sobre-programacao/
https://blog.betrybe.com/tecnologia/aprenda-tudo-sobre-programacao/
https://blog.betrybe.com/tecnologia/codigo-fonte/
https://blog.betrybe.com/carreira/squad/
https://blog.betrybe.com/carreira/o-que-faz-um-programador/
https://blog.betrybe.com/tecnologia/comandos-linux/
Vantagens: porque usar Git? 
Você já deve ter percebido algumas vantagens em usar Git até aqui, mas vamos falar mais sobre elas: 
Desempenho 
O Git pode ser considerado um dos melhores softwares de controle de versão quanto a performance. 
Todas as operações são pensadas para trazer praticidade e desempenho. Como ele também é 
distribuído, isso traz ainda mais agilidade para o desenvolvimento, já que você consegue fazer 
alterações no seu projeto sem uma conexão à internet. 
Flexibilidade 
Uma das grandes vantagens do Git é você conseguir adaptar formatos de trabalho não lineares e ainda 
conseguir rastrear cada uma dessas ramificações. Independente se o seu projeto é grande ou pequeno, 
você consegue adaptá-lo para o seu fluxo. 
Segurança 
Uma das prioridades é a integridade do código fonte do seu projeto. Todas as informações, conteúdos 
de código, versões, commits, tudo é protegido com SHA1, que é um algoritmo seguro de hash de 
criptografia. Isso proporciona mais segurança contra alterações acidentais ou maliciosas e também 
permite que o histórico de alterações seja totalmente rastreável. 
Desvantagens 
Como toda e qualquer decisão, precisamos olhar as desvantagens, e na escolha de um controle de 
versão não seria diferente. As principais desvantagens no uso do Git são: 
Maior complexidade 
O Git pode ser mais complexo de se entender no início, por conta da enorme possibilidade de 
combinações e de ramificações do seu código. Todo esse entendimento pode ficar mais complicado de 
entender. 
Além disso, exige que as pessoas desenvolvedoras tenham um conhecimento maior sobre o seu uso. 
Mas, depois dessa curva de aprendizado, agiliza o desenvolvimento e a entrega do time. Isso faz com 
que necessite de uma maior preparação tanto da equipe quanto dos processos do time. 
 
https://blog.betrybe.com/carreira/gestao-do-tempo-dicas-essencias/
https://blog.betrybe.com/tecnologia/como-melhorar-a-internet/
https://blog.betrybe.com/tecnologia/algoritmo/
https://blog.betrybe.com/tecnologia/seguranca-da-informacao/
https://blog.betrybe.com/carreira/hacker/
https://blog.betrybe.com/carreira/desenvolvedor-de-software/
https://blog.betrybe.com/carreira/passos-fundamentais-para-aprender-a-programar/
O que são repositórios, commits e branches? 
Repositórios 
Um repositório, ou repo, é um diretório onde você armazena os arquivos do seu projeto, que 
podem ser códigos, imagens, áudios, vídeos ou qualquer coisa relacionada a esse projeto. Ele pode 
ficar armazenado no seu computador, um repositório local, ou também ser armazenado em alguns 
serviços como GitHub, BitBucket ou GitLab, ou seja, um repositório remoto. 
Branches 
Branch significa “ramo”, ou seja, uma ramificação do seu código. Imagine a seguinte situação: você 
tem o seu código que já está funcionando em produção e precisa desenvolver uma nova 
funcionalidade (“feature”). Mas você não pode mexer direto no código em produção. 
Para isso, você cria uma ramificação do seu código, uma branch, em que você pega o estado atual 
daquele código e cria um novo ambiente para desenvolver a nova feature a partir dali. 
Dessa forma, você não altera a versão principal do seu código, consegue desenvolver sua 
funcionalidade com segurança, e quando esse código estiver funcionando, você poderá colocar ele na 
principal (ou fazer o merge, que falaremos mais adiante nesse post). 
 
Commits 
Um commit é um conjunto de alterações que você fez em um projeto. Ele marca uma versão do seu 
código. Um commit guarda as alterações feitas nos arquivos, quem fez essas alterações e 
uma mensagem que resume essa alteração. 
Além disso, cada commit tem um hash único SHA1 que pode ser usado para acompanhar todas as 
alterações feitas no passado e inclusive pode ser usado para voltar em alguma alteração específica ou 
em algum ponto no tempo específico do seu código. 
Porque usar vários branches? 
A grande vantagem na possibilidade de ter várias branches é conseguir ter mais de uma “área de 
trabalho” sem alterar a branchprincipal. Vamos trazer um exemplo: imagine que você tenha um 
sistema que está funcionando e já está em produção. Agora você vai precisar implementar uma nova 
feature para ele. Você não pode alterar direto o código que está lá em produção, por isso, você cria 
uma nova branch (a feature por exemplo), e você vai partir do código que estava funcionando em 
produção. 
https://github.com/
https://bitbucket.org/
https://about.gitlab.com/Mas enquanto você estava implementando essa nova feature (lá pelo commit 4 da imagem abaixo), 
apareceu um bug no sistema e você tem que parar o que está fazendo e consertá-lo. Para isso, você 
novamente cria uma nova branch a partir do que está em produção para corrigir o problema. Depois 
de pronto, você consegue voltar para a sua feature sem problemas. 
Essa é uma das maiores vantagens de você trabalhar em branches. Poder focar em pequenas 
implementações, sem afetar o que já está funcionando, e poder trocar esses contextos, voltar e 
criando essas ramificações, enquanto a sua branch main continua funcionando. 
 
Como funciona um repositório local e quais suas zonas virtuais? 
Quando estamos trabalhando em um repositório, temos três diferentes tipos de zonas virtuais: 
• Working directory; 
• Staging area; 
• Commit area. 
O Working Directory, também conhecido como Working Tree, é a área em que você está 
trabalhando. Onde estão todos os seus arquivos, onde você criará novos arquivos, deletará os 
velhos ou alterará os que já existem. Também é onde estão os arquivos untracked. 
Após alterações nos arquivos, o próximo passo é adicionar essas alterações na área de staging. 
Também conhecida como index, é quando o Git passa a salvar aquele estado dos seus arquivos. É como 
se fosse uma prévia do seu commit. O interessante é que se você fizer uma alteração em um arquivo, 
adicionar ele na staging area e depois fizer uma nova alteração nesse mesmo arquivo, essa alteração 
estará no working directory novamente. E a alteração anterior continuará na staging area. 
O próximo passo é pegar todas as alterações de staging e fazer um commit com elas. Quando você faz 
isso, esse commit vai para a commit area ou também conhecida como local repository. Aqui fica tudo 
do seu repositório. É por isso que você consegue trabalhar de maneira offline, podendo executar suas 
tarefas e fazer commits sem precisar se conectar a nenhum repositório remoto. 
https://blog.betrybe.com/tecnologia/o-que-e-bug/
 
Newsletter da TrybeJunte-se a mais de 100.000 pessoas da nossa tribo que recebem conteu dos gratuitos e 
exclusivos em nossa newsletter semanal! 
Quais as diferenças entre Git e GitHub? 
Basicamente, o Github é uma plataforma usada para gerenciar, hospedar códigos e arquivos, além de 
facilitar a criação de ambientes de colaboração entre pessoas desenvolvedoras. O GitHub usa como 
sistema de controle de versão o Git. Ou seja, o GitHub facilita e auxilia a usar o Git no dia a dia. 
O Git é um sistema de controle de versão local, ele ajuda quem desenvolve a manter o histórico das 
versões ao longo do tempo, e traz vantagens para o desenvolvimento individual. Já o GitHub usa os 
recursos dele para serem usados de forma colaborativa, auxiliando o gerenciamento desses projetos e 
também dos times, além de também ser uma rede social e contribuir para o universo open source. 
Git vs SVN: qual é melhor? 
O SVN, ou Apache Subversion, é também um sistema de controle de versão, mas com algumas 
diferenças em relação ao Git. Para começar, o SVN armazena todos os projetos e suas versões em um 
servidor único, ou seja, é centralizado. Com um commit, as alterações vão direto para 
esse servidor. Enquanto isso, o Git é totalmente distribuído e tem alguns recursos que auxiliam, 
como ter uma área de staging, branches, merges e pull requests. 
O fato do SVN ser centralizado faz com que seja mais simples aprender a usá-lo e a não ter toda aquela 
complexidade que já falamos que o Git tem. 
Os dois são sistemas de controle de versão viáveis, mas você precisa escolher de acordo com suas 
necessidades. Fora o que já falamos, o Git tem mais dificuldades em compactar e guardar arquivos 
binários. 
O Git pode funcionar melhor para quem desenvolve e não tem disponibilidade de estar sempre 
conectado ao repositório principal, porque existe a possibilidade de trabalhar offline. 
3 boas práticas ao usar Git 
https://blog.betrybe.com/tecnologia/git-e-github/
https://blog.betrybe.com/tecnologia/o-que-e-servidor/
https://blog.betrybe.com/tecnologia/tar-compactando-e-descompactando/
https://blog.betrybe.com/tecnologia/codigo-binario/
https://blog.betrybe.com/tecnologia/codigo-binario/
1. Faça pequenos commits 
Não deixe para commitar apenas quando você terminar tudo. Faça pequenos ciclos com o código 
funcionando e vá commitando. Isso evita que você perca todo o código que fez e também facilita a 
volta em alguma parte que deu errado. 
2. Escreva boas mensagens de commits 
Se você é uma pessoa desenvolvedora, provavelmente já esbarrou em algum projeto em que você 
tentou entender o que o código faz e a mensagem do commit não ajudou em nada! E, se ainda não 
passou por isso, é provável que um dia vai passar. 
Portanto, escrever boas mensagens no commit que representem o que aquela modificação 
faz ajuda muito outras pessoas do time — ou até mesmo você, quando for revisitar um código daqui 
uns meses ou anos. 
3. Use o .gitignore 
Existe um arquivo que você pode criar em todos os repositórios, na raiz, com o nome .gitignore. 
Nesse arquivo, você pode colocar todas as pastas e arquivos que você quer que o Git ignore e não faça 
track. 
3 ferramentas gráficas para usar em Git 
Existem algumas ferramentas gráficas que ajudam você a usar o Git. Há diferentes tipos de 
ferramentas no mercado, pagas e não pagas, mas vamos te mostrar 3 alternativas multiplataformas 
que tem planos gratuitos. 
1. Git Kraken 
Além de eficiente e visualmente agradável, o GitKraken faz com que as operações do Git sejam mais 
compreensíveis e simples de entender. 
2. Git-cola 
É uma ferramenta mais simples, porém bem poderosa para você executar seus comandos Git. 
3. SmartGit 
Como o próprio nome já diz, é uma ferramenta inteligente e fácil de usar. Independentemente do 
sistema operacional que estiver usando, ele funciona da mesma maneira. 
Download e instalação do Git 
https://www.gitkraken.com/
https://git-cola.github.io/downloads
https://www.syntevo.com/smartgit/download/
Como instalar o Git no Windows 
Para instalar o Git no Windows, basta baixar o instalador mais recente aqui e seguir os passos da 
instalação. 
Como instalar o Git no Linux 
Se você tem um Debian/Ubuntu, pode baixar via apt-get, usando o comando: 
$ sudo apt-get install git 
Agora, se você usa Fedora, pode usar o comando: 
$ sudo dnf install git 
Para verificar se está instalado, basta rodar: 
$ git --version 
Como instalar o Git no MacOS 
Existem várias formas de instalar o Git no seu Mac. Talvez ele já esteja até instalado, caso você já tiver 
instalado o Xcode ou suas ferramentas de linha de comando. Para saber se ele já está em sua máquina, 
abra o seu terminal e digite: 
$ git --version 
Se não tiver instalado, aparecerá uma janela para instalar. Agora, se você quiser instalar a versão mais 
recente, pode ver todas as opções de como instalar neste site. Você pode instalar via Homebrew, 
usando o comando: 
$ brew install git 
Ou também usar o instalador mais recente, que você pode encontrar aqui. 
Git config: como configurar o seu git? 
Agora que você já tem ele instalado no seu computador, você pode configurar ele com seus dados. 
Abra um terminal e rode os seguintes comandos lembrando de alterar o que está em aspas pelo seu 
nome e seu e-mail: 
$ git config --global user.name "Seu Nome" 
https://gitforwindows.org/
https://git-scm.com/download/mac
https://sourceforge.net/projects/git-osx-installer/
$ git config --global user.email "exemplo@seuemail.com.br" 
Essas configurações ficam em um arquivo chamado .gitconfig. No Linux e Mac, esse arquivo fica 
em ~/.gitconfig, enquanto no Windows fica em c:\Usuarios\<username>\.gitconfig. 
Conheça 17 comandos Git e saiba para que servem! 
1. Git init: criando seu repositório local! 
O git init serve para que você crie o seu repositório localmente, no seu computador. Para isso, se você 
quiser criar um novo repositório, crie uma pasta (ou se você quiser iniciar um repositório em umapasta que já existe, vá até ela) e digite o comando git init e pronto, seu repositório Git foi criado! 
 
 
2. Git add: adicionando alterações no repositório! 
Quando você cria ou modifica arquivos, você precisa adicionar eles para a área de staging, para isso 
você usa o comando git add* para adicionar todos os arquivos ou git add<nome-do-arquivo>. Dessa 
forma, os arquivos estarão prontos para serem commitados. 
3. Git commit: confirmando e salvando as alterações no repositórios! 
Após você usar o git add, os arquivos vão para a área de commit. Você pode empacotar todas essas 
alterações em um único commit com uma mensagem que resume aquelas alterações. Para isso você 
usa o comando git commit-m “Mensagem das alterações”. 
4. Git Status: verificando se há alterações na branch 
O git status mostra o status do seu repositório naquele momento. Ele mostra o working directory, 
a staging area com todos os arquivos em cada uma das áreas e qual o estado de cada um deles. Isso 
ajuda muito quando precisamos pensar em fazer um commit ou até mesmo verificar quais foram todos 
os arquivos modificados. 
 
 
5. Git log: verifique quais commits foram feitos até agora 
O git log ajuda a saber quais foram os commits feitos no seu repositório, quem fez, quando e também 
qual a mensagem de cada um. Além disso, esse comando te mostra a hash de cada um dos commits, o 
que pode ajudar a executar alguns outros comandos também. 
https://blog.betrybe.com/tecnologia/comandos-windows/
 
 
 
6. Git reset: desfazendo as alterações de um repositório para um commit anterior! 
O git reset é uma forma bem complexa para desfazer alterações. Teremos um post totalmente focado 
para falar dele, mas para falar sobre a forma mais usada dele, vamos dar dois exemplos. O primeiro 
deles é quando, localmente, precisamos voltar um commit. No exemplo da imagem abaixo, temos dois 
commits e queremos voltar para o primeiro. Para isso, usamos o comando: 
git reset <hash do commit que queremos voltar> 
Se você perceber, após rodar esse comando, o último commit sumiu e as alterações voltaram para 
o working directory. 
 
 
 
 
Um outro exemplo bem usado é quando você quer voltar ao estado original que estava no repositório 
remoto. Importante lembrar que ao rodar esse comando, você perderá o que está localmente! Logo, 
rodando esse comando, você recuperará o histórico mais recente da branch main do servidor e 
apagará todas as alterações e commits locais. 
git reset --hard origin/main 
7. Git revert: Desfazendo um commit sem excluir os dados existentes! 
O git revert faz parte de comandos do tipo “desfazer”. Mas ele não é uma opção tão tradicional. 
Basicamente, ele cria um novo commit desfazendo o commit que você especificar. 
Criei um arquivo, adicionei um texto “primeiro conteúdo” e depois adicionei outro texto “conteúdo 
errado”. Fiz o revert do “conteúdo errado” e como pode ver, ele adicionou um novo commit fazendo 
o revert. Nesse commit, ele desfez as alterações do último commit. Ou seja, no final, o meu arquivo 
ficou apenas com o texto “primeiro conteúdo”. 
 
 
 
 
8. Git diff: verificando as diferenças entre arquivos e repositórios! 
Você pode ver as diferenças dos seus arquivos ou também entre os repositórios local e remoto. Para 
isso, você pode rodar o comando git diff depois das alterações que você fizer no seu repositório local 
ou, se você precisar ver antes de um merge, por exemplo, você também pode executar git diff 
<branch origem> <branch destino>. 
 
 
 
 
9. Git remote: ligando seu repositório local a um repositório remoto! 
Se você não clonou um repositório, você pode ligar o seu repositório local a um servidor com o 
comando remote. Para isso, basta usar git remote add origin <servidor>. 
10. Git push: enviando as alterações do repositório local para o repositório remoto! 
Depois que você fez as alterações, adicionou para a área de staging, fez os commits, você pode fazer 
o push. Ou seja, você consegue mandar todas essas alterações do seu repositório local para um remoto. 
Para isso, use o comando git push origin main, no qual main pode ser substituúida por qualquer 
outra branch que você estiver trabalhando. 
11. Git branch: listando e deletando branches 
Para listar todas as branches que estão em um repositório, basta rodar git branch. Para deletar uma 
branch específica basta rodar git branch -d nome_da_branch. 
12. Git checkout: criando uma nova branch e restaurando arquivos! 
Para criar uma nova branch, você deve rodar o comando git checkout -b nome_da_branch. E, para 
alternar entre branches, basta rodar git checkout nome_da_branch. 
Agora, se você tiver feito algo errado e quiser restaurar o arquivo ao seu estado original, você pode 
rodar git checkout — nome_do_arquivo. Mas, isso só funcionará se o arquivo ainda estiver 
no working directory. Caso já esteja na área de staging, você terá que, primeiro, fazer um reset para 
depois conseguir fazer um checkout. 
13. Git merge: mesclando as alterações em sua branch à branch master 
Quando você precisa trazer as atualizações da branch main, a principal, para a branch que você está 
trabalhando, basta rodar da sua branch: git branch main. Se não tiver nenhum conflito nos arquivos 
que você mexeu na sua branch com as alterações da main, você não terá que fazer mais nada. Agora se 
tiver algum conflito, vai aparecer no seu terminal que houve um conflito e quais os arquivos 
conflitantes. Você precisará abrir cada um deles e escolher qual versão do código você vai querer 
manter. 
14. Git pull: atualizando o repositório local com a versão do repositório remoto! 
Quando você precisa atualizar o seu repositório local com a mais nova versão do repositório remoto, 
basta usar o comando git pull. Dessa forma, ele verificará se tem uma versão mais recente e, se tiver, 
vai baixar as diferenças para o seu computador. 
15. Git rebase: integrando todas as alterações de um branch em outro branch 
O git rebase move e combina sequências de commits para uma nova branch de uma forma mais linear. 
Uma das diferenças do rebase para o merge é que o rebase mantém esse histórico do projeto de uma 
forma mais linear e organizada. O comando é simples, mas todo o conceito de como ele funciona é 
mais complexo. Para rodar, basta usar git rebase <branch>. Na imagem abaixo, mostramos o que 
acontece com o histórico quando fazemos um rebase: 
 
16. Git stash: criando um backup das alterações atuais do seu projeto 
O git stash serve para guardar ou arquivar as alterações que você fez por um determinado tempo. Ele 
é bem útil quando você precisa mudar de contexto rápido e ainda não está pronto para fazer 
um commit, ou também quando você precisa fazer um teste de uma nova linha de pensamento e não 
quer perder tudo que já fez antes de ter certeza que a nova abordagem funcionará. Para usar o 
comando git stash e para recuperar as alterações, basta usar git stash pop. 
17. Git clone: baixando o código fonte de um repositório! 
Você consegue clonar, ou copiar, o projeto para o seu computador. Você pode clonar um 
repositório localmente, fazendo uma cópia dele. Para isso, basta rodar git clone 
/caminho/para/o/repositório. Ou você também pode clonar um repositório remoto e para isso 
usar git clone “url”. 
 
https://blog.betrybe.com/tecnologia/tudo-sobre-cli/
https://blog.betrybe.com/carreira/pensamento-sistemico/
https://blog.betrybe.com/tecnologia/tudo-sobre-localhost/