Gostaria de saber se faz sentido dividir o projeto no qual estou trabalhando em dois repositórios, em vez de um.
Pelo que posso dizer:
- O frontend será escrito em html + js
- Back-end em .net
- O back-end não depende do front-end e o front-end não depende do back-end
- O front-end usará uma API repousante implementada no back-end.
- O front-end pode estar hospedado em qualquer servidor http estático.
A partir de agora, o repositório tem esta estrutura:
raiz:
- a parte dianteira/*
- back-end / *
Eu acho que é um erro manter os dois projetos no mesmo repositório. Como os dois projetos não têm dependências entre si, eles devem pertencer a repositórios individuais e, se necessário, a um repositório pai que possua submódulos.
Foi-me dito que é inútil e que não obteremos nenhum benefício em fazer isso.
Aqui estão alguns dos meus argumentos:
- Temos dois módulos que não dependem entre si.
- Ter o histórico de origem de ambos os projetos a longo prazo pode complicar as coisas (tente pesquisar no histórico por algo no front-end enquanto você tiver metade dos commits que não têm nenhuma relação com o bug que está procurando)
- Conflito e fusão (isso não deve acontecer, mas ter alguém empurrando para o back-end forçará outro desenvolvedor a puxar alterações de back-end para empurrar alterações de front-end).
- Um desenvolvedor pode trabalhar apenas no back-end, mas sempre precisará puxar o front-end ou o contrário.
- A longo prazo, quando será a hora de implantar. De alguma forma, o front-end pode ser implantado em vários servidores estáticos enquanto você possui um servidor de back-end. Em todos os casos, as pessoas serão forçadas a clonar o back-end inteiro ou a criar scripts personalizados para enviar a todos os servidores apenas o front-end ou remover o back-end. É mais fácil empurrar / puxar apenas o front-end ou back-end do que ambos, se apenas um for necessário.
- Contra-argumento (uma pessoa pode trabalhar nos dois projetos), Crie um terceiro repositório com o submódulo e desenvolva-o. O histórico é mantido separado em módulos individuais e você sempre pode criar tags nas quais a versão do back-end / front-end realmente funciona em sincronia. Ter o front-end / back-end juntos em um repo não significa que eles trabalharão juntos. É apenas mesclar a história em um grande repositório.
- Ter front-end / back-end como submódulos facilitará as coisas se você quiser adicionar um freelancer ao projeto. Em alguns casos, você realmente não deseja dar acesso total à base de código. Ter um grande módulo tornará as coisas mais difíceis se você quiser restringir o que os "estranhos" podem ver / editar.
- Introdução e correção de bugs, inseri um novo bug no frontend. Então alguém corrige um bug no back-end. Com um repositório, a reversão antes do novo bug também reverterá o back-end, o que pode dificultar a correção. Eu precisaria clonar o back-end em uma pasta diferente para que o back-end funcionasse enquanto corrigia o bug no front-end ... depois tentava refazer as coisas ... Ter dois repositórios será indolor porque mover o HEAD de um repo ganhou mude o outro. E testar contra versões diferentes do back-end será indolor.
Alguém pode me dar mais argumentos para convencê-los ou pelo menos me dizer por que não faz sentido (mais complicado) dividir o projeto em dois submódulos. O projeto é novo e a base de código tem alguns dias, portanto não é muito cedo para corrigir.
fonte
Alguns de seus argumentos são válidos e outros não.
Na verdade, isso não é inteiramente verdade. Para poder se comunicar, o front-end e o back-end precisam ter uma interface comum (descrição). Isso o torna um argumento fraco em favor de ter os dois em um repositório comum. Mas apenas um argumento fraco, pois não faz muita diferença.
Este é um argumento falso. Se você deseja verificar como um bug específico foi corrigido, procure no rastreador de erros para o qual o commit contém a correção. E se você quiser saber como um determinado código evoluiu, analise o histórico de um único arquivo (ou, no máximo, um punhado). Em qualquer um dos casos, ter outros arquivos, possivelmente de outros módulos, no repositório não deve complicar as coisas de forma alguma.
Este é um argumento falso. Não conheço nenhum VCS (meio decente) em que você precise sincronizar todo o repositório antes de confirmar / enviar suas alterações. No máximo, você precisa sincronizar as pastas que contêm os arquivos alterados (e geralmente apenas os próprios arquivos).
Este é o mesmo argumento falso que o anterior.
Dependendo de como as pessoas imaginam que a implantação será feita, esse pode ser um argumento válido. Se a implantação for feita descompactando um arquivo zip / tarbal no servidor, não importa como seus repositórios estão organizados. Se a implantação for feita através do check-out (parte de) de um repositório no servidor, pode ser uma boa ideia usar repositórios separados para módulos implantados separadamente.
Este é um argumento válido, mas não é tão forte.
Este é um argumento válido.
Esse é um argumento falso, porque significaria que, após duas correções de bug em um módulo, você não seria capaz de reverter o primeiro. Qualquer VCS meio decente permitirá reverter praticamente qualquer confirmação antiga (embora muitas vezes signifique que você faça uma nova confirmação que reverta essas alterações, às vezes até para o topo da HEAD).
Este é realmente um bom argumento. A existência de dois repositórios facilita o teste dos cenários em que os front-ends e back-ends implantados podem ficar (ligeiramente) fora de sincronia.
fonte
Este post é um pouco antigo, mas eu gostaria de contribuir. Embora seu back-end realmente não saiba sobre o front-end, ele precisa ter solicitações correspondentes à API do back-end. Se você considerar seu back-end como uma API REST, poderá definir um arquivo de interface como uma interface YAML swagger. Agora, existem realmente três projetos, que você pode dividir individualmente em diferentes repositórios, como achar melhor:
A definição da API é uma dependência nos outros dois projetos, digamos que você estava usando o maven como uma ferramenta de injeção de dependência. Depois, depende de quão estritamente você deseja fazer o controle de versão. Você pode aumentar a versão do projeto de definição de API sempre que fizer uma alteração para garantir que os projetos estejam sempre em um estado compatível, mas exija mais sobrecarga, ou use algo como SNAPSHOTS no maven e faça o versionamento apenas depois de está satisfeito com a interface, que é menos sobrecarga, mas muitas vezes você pode ter incompatibilidades. Mas, desde que você aplique a definição da API em seu front e back-end, você poderá dividir os projetos em diferentes repositórios.
Esses problemas são mais sobre o gerenciamento de dependências. Mesmo que os projetos não estejam divididos e estejam no mesmo repositório, é muito fácil para o site ser colocado em um estado em que o front-end e o back-end estejam fora de sincronia. Realmente, a única maneira de impedir isso é realmente definir o contrato entre os dois, mas você deseja fazê-lo de uma maneira que não acoplar as implementações do front e back-end, da mesma forma que codificaria para uma interface. de uma implementação na programação OO.
Também para lidar preventivamente com as críticas de que isso cria uma sobrecarga na manutenção desse arquivo de interface, o swagger, por exemplo, pode até produzir stubs de código para diferentes linguagens de programação e estruturas, como JAX-RS. Portanto, você pode produzir uma interface com a tecnologia escolhida e implementar essa interface. Também adiciona uma documentação muito boa ao seu back-end, facilitando o trabalho dos desenvolvedores de front-end.
fonte