Controle de versão principal para equipes remotas

Trabalhar remotamente tornou-se muito mais comum no desenvolvimento da web nos últimos anos. Antes do controle da versão, funcionar remotamente no mesmo projeto de desenvolvimento teria sido um pesadelo absoluto. Os desenvolvedores teriam que Envie arquivos grandes para o outro (provavelmente por e-mail), colando em seu próprio código antes de enviá-lo de volta. Não havia uma maneira real de acompanhar o que foi adicionado e quando.

• 6 Must-have habilidades para jovens desenvolvedores da Web

Felizmente, o controle da versão chegou e fez o desenvolvimento em todas as frentes muito mais gerenciáveis. Os projetos da Web tornaram-se muito mais fáceis de implementar e gerenciar, especialmente quando se trata de trabalhar em uma equipe de desenvolvimento remoto. Você não precisa mais se preocupar com a versão atual de um site sendo sobrescrito - cada membro da equipe é livre para trabalhar em qualquer arquivo a qualquer momento, não há confusão sobre onde a versão mais recente de um arquivo está sendo armazenada - e superior armazenamento na núvem ajuda com o processo também.

Neste tutorial, vamos estar usando Github para gerenciar nosso código. Existem inúmeros tipos diferentes de ferramenta de controle de versão por aí, como Bitbucket e TFVC, mas mesmo que sejam todos diferentes, os princípios permanecem os mesmos quando se trata de gerenciar o código.

Por mais maneiras de tornar o seu site de construção do processo mais fácil, consulte Nossos guias para o topo Construtor de sites e hospedagem na web. serviço.

Modelo de ramificação

Em primeiro lugar, é muito importante ter um modelo de ramificação bem-sucedido ao trabalhar em qualquer equipe para fazer o processo de desenvolvimento e implantação funcionar sem problemas. Você provavelmente terá vários desenvolvedores trabalhando no mesmo projeto. Ao trabalhar com uma força de trabalho remota, acredito que o melhor fluxo de trabalho é composto por três filiais principais, bem como um conjunto de temporários:

• Desenvolver filial: Cada linha de código foi testada e validada pelo cliente.
• Filial de preparação: Isso corresponderá ao ambiente de validação.
• Ramo de lançamento: Isso contém a última versão do seu site em produção.

Haverá também um conjunto de ramos de recursos. No entanto, estes serão apenas temporários para criar inicialmente os novos recursos.

Vários desenvolvedores em um projeto

Vamos supor que você administre uma equipe com dois desenvolvedores que trabalham remotamente. Vamos chamá-los de Sarah e James: ambos estão trabalhando no mesmo site de comércio eletrônico para um cliente. Sarah precisa desenvolver um recurso que registre os detalhes do cliente.

Nós iríamos quebrar isso em três histórias de usuário separadas - adicionando, editando e removendo - e adicione esses três ingressos no backlog Sprint.

Rames de recursos

Então, digamos que Sarah começa na seção Adicionar detalhes do cliente. Ela precisaria criar a ramificação do recurso 'Detalhes do cliente' e uma história de usuário para a primeira tarefa 'add-detalhes'.

 Git Checkout Desenvolvimento & Amp; & Amp; Git puxar a origem / desenvolver
Git Checkout -B Recurso / Detalhes do Cliente
Git checkout -b add-detalhes 

Sarah continuaria a trabalhar no ramo temporário 'add-add-add' localmente e cometer seu trabalho como ela se desenvolve. Agora, digamos que James quer ajudar Sarah com o recurso de detalhes do cliente, então ele começa a trabalhar na exclusão detalhada.

James extrairia a última versão do ramo compartilhado e criaria uma nova filial para a história do usuário 'Detalhes-Details'. Então ele pode começar a fazer suas próprias adições sem se preocupar em substituir o código de Sarah.

 Git Checkout Recurso / Detalhes do Cliente
Git puxar a origem / recurso / detalhes do cliente
Git Checkout -B Excluir-detalhes 

Ele também usará seu ramo temporário para codificar localmente e cometer quaisquer alterações. Uma vez que Sarah terminou seu recurso localmente, ela coloca o ingresso na revisão de código. Ela empurraria seu código para o ramo de preparação e abriria uma solicitação de tração com o ambiente de encenação.

// ela empurra seu código para o ramo de preparação
Git Push Origor Add-Details
// ela abre uma solicitação de tração com o ambiente de encenação
Git Request-Puxe Staging Add-Details 

Nós agora teríamos o ramo do recurso de detalhes do cliente e os dois recursos de recurso de história do usuário em desenvolvimento 'add-details' e 'delete-detalhes'.

Fundir

Uma vez que seu código tenha sido revisado, ela pode mesclar seu ramo em encenação. O bilhete está agora na coluna de validação, aguardando a validação do desenvolvedor principal.

 // ela recebe a última versão do ramo de preparação
Git checkout encenação e amp; e amp; Git puxar a origem / encenação
Git Merge Adicionar-Details & Amp; & Amp; Git Push Orurg Staging
// ela constrói o ambiente de validação
// e pede ao proprietário do produto para validar 

Depois que o trabalho de Sarah foi validado, o bilhete pode ser movido para a coluna FEITO. Ela pode mesclar seu trabalho na filial e iniciar outra história de usuário, como exclusão dos detalhes do cliente.

 // ela puxa a última versão do ramo de recurso
Recurso de checkout Git / detalhes do cliente
Recurso de origem git / detalhes do cliente
git mesclar add-add-add & amp; & amp; Git Push Origem Recurso / Detalhes do Cliente 

Quando todo o recurso foi validado pelo desenvolvedor e do cliente principal, a Sarah pode mesclar a ramificação do recurso em desenvolvimento, como está pronto para ir.

 // ela recebe a última versão do ramo de desenvolvimento
Git checkout desenvolver e amp; e amp; Git puxar a origem / desenvolver
Recurso Git Merge / Detalhes do Cliente & Amp; Origem Push Git desenvolver 

Implante na produção

Quando tudo estiver completo e estiver pronto para implantar em produção, James Mesclats se desenvolve para a liberação e lança a implantação. Neste ponto, ele saberia que todo o código está correto e o cliente é feliz. Ele marca o compromisso do lançamento para obter o histórico de cada versão.

 Git Checkout Desenvolvimento & Amp; & Amp; Git puxar a origem / desenvolver
Git Checkout Release & Amp; & amp; Git puxar a origem / liberação
git mesclar desenvolver e amp; e amp; Git Tag 2.1.
Git Push Origin Rede --Tags 

Regras a seguir para este fluxo de trabalho

Este fluxo de trabalho de desenvolvimento remoto pode ser bastante difícil de entender a princípio, mas se você conseguir que sua equipe funcione por este método, então você tem um fluxo de trabalho livre sem a necessidade de entrar em pânico sobre arquivos sendo sobrescritos ou seus desenvolvedores trabalhando na mesma área.

Existem algumas coisas importantes para lembrar:

• A primeira coisa que você precisará ensinar seus desenvolvedores remotos é o seu fluxo de trabalho de controle de versão e certifique-se de que todos estão lendo do mesmo livro.
• Se você estiver desenvolvendo um recurso, tente quebrar isso em histórias de usuários menores. Desta forma, é mais fácil acompanhar cada confirmação.
• Não perca nenhuma etapa: o mesmo fluxo de trabalho deve ser seguido a cada vez.
• Você sempre precisará mesclar seu ramo para desenvolver para preparar o próximo lançamento.
• Você deve limpar o repositório de encenadores toda semana, se possível. Você deve excluir o ramo de estadiamento, local e remotamente, e recriá-lo de desenvolver ramificação - ver exemplo abaixo:

 Git Co desenvolver & amp; & amp; Git puxar a origem / desenvolver
git ramo -d staging & amp; & amp; Git Push Origem - Delete Encenando
Git Co -B Staging & Amp; & Amp; Git puxar a origem da origem 

Fluxos de trabalho adicionais

Com projetos menores, você pode querer usar um fluxo de trabalho menos complexo. Você poderia usar o mestre, que contém a versão mais atualizada, um ramo de desenvolvimento e, em seguida, um conjunto de ramificações para cada recurso adicional - se esse seja fórum, formulário de contato, sistema de checkout. Tudo depende da sua preferência pessoal.

Gerenciando conflitos de mesclagem

Lidar com conflitos de mesclagem é difícil o suficiente se você estiver trabalhando na mesma sala, mas eles podem se tornar ainda mais de um pesadelo se você estiver trabalhando em um escritório diferente. O mais importante é lembrar que você sempre pode desfazer uma mesclagem e reverta para o estado antes que o conflito tenha ocorrido.

Se você está fazendo todas as mesmas como desenvolvedor de chumbo ou sua equipe, os que os fazendo de forma independente, o primeiro passo é entender o que aconteceu.

• Um dos seus co-desenvolvedores editou a mesma linha no mesmo arquivo?
• Eles excluiram um arquivo que você modificou?
• Vocês dois adicionaram um arquivo com o mesmo nome?

Git dirá que você tem caminhos não feridos através da Status do Git. :

 $ git status
# No sistema de check-out da filial
# Você tem caminhos não feridos.
# (consertar conflitos e executar "git commit")
Miserável
# Caminhos não feridos:
# (use "git add & lt; file & gt; ..." para marcar resolução)
Miserável
# ambos modificados: checkout.html
Miserável
Nenhuma alteração adicionada a confirmar (usar "git add" e / ou "git commit -a") 

Agora, a causa mais comum de um conflito é quando as alterações afetam os mesmos arquivos na mesma linha. Então, vamos dar uma olhada no conteúdo da linha conflituosa. Você notará que o Git é realmente bom no fato de que vai marcar a área conflituosa, colocando-a em & lt; & lt; & lt; & lt; & lt; & lt; cabeça e & gt; & gt; & gt; & gt; & gt; & gt; [outro / ramo / nome] . Neste caso, é Sistema de checkout .

 & lt; & lt; & lt; & lt; & lt; & lt; CABEÇA
Esta linha foi confirmada enquanto trabalhava no ramo "formulário de usuário".
=======.
Esta linha, em contraste, foi confirmada enquanto trabalhava no ramo "Sistema de checkout-System".
& gt; & gt; & gt; & gt; & gt; & gt; Refs / Heads / Sistema de Checkout 

O conteúdo após o primeiro marcador se originam do seu ramo de trabalho atual. Depois que os suportes angulares, Git nos diz qual ramo as mudanças vieram. Uma linha com =======. separa as duas mudanças conflitantes.

Agora você pode simplesmente abrir o arquivo em um editor, pesquisar os marcadores de conflito e fazer as modificações necessárias. Quando terminar, o arquivo precisa ser exatamente como você quer que ele pareça ou, alternativamente, você pode dizer que você simplesmente irá com uma das versões editadas, chamada nosso ou deles .

 Git checkout --ours caminho / para / conflito-ficheiro.html 

Há também muitas aplicações de ferramentas de mesclagem que podem ajudar com isso. O caleidoscópio é um ótimo para Mac.

Gerenciamento de projeto e emissão

É tão importante quanto um desenvolvedor de leads para ter uma ferramenta de gerenciamento de projetos para gerenciar coisas como tarefas e bugs, especialmente quando seus desenvolvedores não são baseados no escritório. Existem inúmeras soluções por aí, como Zenhub e Asuna, mas acredito que o projeto e o sistema de problemas integrados do Github é o melhor.

Você pode fazer coisas como configurar um novo projeto, criar placas ou atribuir problemas. E não apenas confunda problemas com problemas: você também pode usá-lo para aprimoramentos, perguntas e insetos, entre outras coisas.

Aqui estão alguns dos seus melhores recursos:

• Sistema de marcação integrado: Permite organizar e priorizar seu fluxo de trabalho e pesquisar facilmente por meio de projetos para informações relevantes.
• Milestones: Perfeito para associar problemas com recursos específicos ou fases do projeto, como bugs que precisam ser fixados antes de um lançamento beta ou tarefas a serem concluídas em outubro.
• Multi Atribuições: Os problemas podem ser atribuídos aos usuários a granel, economizando tempo e tornando você mais eficiente.
• Comentando: Engenheiros e equipes de gerenciamento podem discutir facilmente o progresso e os resultados a cada passo do caminho usando o sistema de comentários inbuilt.
• Listas de tarefas: Questões maiores podem ser divididas em etapas para desencorajar a criação de dezenas de problemas microscópicos, mantendo todo o seu trabalho no mesmo lugar.
• Formato de Marcação: A capacidade de usar a formatação de marcação será popular com seus desenvolvedores e pode ser usada na maioria dos lugares ao redor do GitHub.
• Placas de projeto: Estes podem ser usados ​​para abrigar questões, puxar solicitações e notas, categorizando-os como cartões em colunas de sua escolha para que você possa analisar projetos maiores como um todo.
• Alta seguranca: Você pode confiar no GitHub para manter seus dados seguros e é mais difícil violar do que a maioria dos outros sistemas de gerenciamento de projetos.

Configurando um projeto

Se você for para o Github e, em seguida, dirija-se a um dos seus repositórios, você verá uma guia que é chamada de projetos. De lá, você pode selecionar novo projeto, configurar os detalhes do seu projeto e criar um novo modelo de projeto.

Se você agora selecionar a guia Problemas que estiver ao longo da parte superior e selecionar novo problema, poderá criar um novo problema. Você pode então aplicar vários rótulos - estas são coisas como bug, aprimoramento, pergunta e duplicadas. Você também pode usar o aprimoramento para um novo recurso ou solicitação. Você pode então atribuir vários membros da equipe à tarefa, um marco e também o projeto que você acabou de criar.

Os membros atribuídos terão uma lista de todas as suas tarefas e você pode até usar o quadro de projetos para manter uma faixa do que está sendo construído atualmente. Se você se lembra do nosso tutorial anterior, estávamos falando de movimentar bilhetes para o backlog e validação do Sprint. Então Github funciona muito bem como uma ferramenta all-in-one para supervisionar um projeto.

Este artigo foi originalmente publicado em questão 311 de internet , a revista mais vendida do mundo para web designers e desenvolvedores. Comprar edição 311 aqui ou Inscreva-se aqui .

Artigos relacionados:

• Como ter sucesso como um desenvolvedor freelance
• Desenvolver componentes reutilizáveis ​​reagir
• 4 dicas para desenvolver suas habilidades de desenvolvedor