Qual é a maneira mais eficaz / eficiente de desenvolver um aplicativo com várias pessoas sem controle de origem?

Introdução à minha situação

Eu trabalho para uma pequena empresa de desenvolvimento web. Temos uma equipe de quatro desenvolvedores do ASP.NET, incluindo eu. Quase todos os nossos projetos (> 98%) são projetos individuais que levam cerca de 1 a 4 semanas para serem concluídos. Não usamos controle de origem ou versão. A única coisa que temos é uma pasta compartilhada em um servidor local que contém a fonte mais recente (== a fonte do aplicativo ativo) de todos os projetos.

Nas raras ocasiões em que precisamos trabalhar no mesmo projeto com mais de uma pessoa, usamos ... Beyond Compare. Uma ou duas vezes por dia, os desenvolvedores se perguntam se têm uma versão que compila e depois sincronizam seu código usando o Beyond Compare. Quando apenas duas pessoas estão trabalhando em um projeto, isso funciona "muito bem", mas, assim que um terceiro desenvolvedor entra no processo, ele se torna um lixo incontrolável. Especialmente quando todos começam a fazer alterações no banco de dados.

Eu (e um ou dois de meus colegas desenvolvedores) já disse ao meu chefe várias vezes que deveríamos começar a usar alguma forma de controle de origem e versão como Git, Mercurial ou TFS (nosso chefe é muito preocupado com a Microsoft). Infelizmente, meu chefe não vê a vantagem de mudar para um sistema de controle de origem e versão, porque aos seus olhos tudo funciona muito bem agora e ele não quer investir tempo e dinheiro na criação de um novo sistema e garantir que todos sabe como usá-lo. Mesmo depois que expliquei as vantagens (como colaboração simplificada, versões diferentes de um aplicativo, maneira mais segura de alterar o código, ...) para ele, ele ainda não acha que é algo que precisamos.

Dos quatro desenvolvedores, apenas dois (incluindo eu) têm experiência com controle de fonte (Git). E essa experiência é muito limitada. Eu sei como clonar um repositório do Github no meu computador, fazer algumas alterações, confirmar e enviá-las de volta ao Github. É isso aí.

Explicação do meu problema / preocupação

Dentro de algumas semanas, começaremos a trabalhar em um projeto bastante grande para nossos padrões. Provavelmente levará de 2 a 3 desenvolvedores por alguns meses para concluir. Serei o líder do projeto (gerente de projeto e desenvolvedor líder) e serei responsável por tudo. Eu tive minha parcela de problemas com a abordagem Beyond Compare e não quero seguir esse caminho com esse grande projeto que será de minha responsabilidade.

Desde que duvido que seremos capazes de

• configurar nosso próprio servidor Git,
• ensinar todos a trabalhar com Git e
• empregar o Git com sucesso neste grande projeto,

Estou interessado se algum de vocês conhece algumas boas maneiras de permitir que várias pessoas colaborem no mesmo projeto sem usar o controle de origem ou versão.

Atualizar

Gostaria de agradecer a todos por suas respostas e comentários. Aqui está o plano:

1. Faça uma reunião com os desenvolvedores para garantir que todas as pessoas técnicas se sintam da mesma maneira sobre a implementação do controle de origem. Faremos um ponto mais forte quando todos estiverem por trás disso.
2. Apresente a idéia ao chefe e diga a ele que realmente precisamos do controle da fonte.
3. Implemente-o o mais rápido possível.

Reserve um dia para instalar o controle de versão e ensine todos no projeto a usá-lo. Não é tão difícil. Pessoalmente, não usei o Git, mas configurei e usei outros sistemas de controle de versão e eles não são tão difíceis de trabalhar. Certifique-se de escolher um que se integre ao seu ambiente de desenvolvimento. Isso tornará o uso praticamente perfeito.

Isso não será perda de tempo.

O tempo que você vai perder quando alguém substitui ou exclusões algum código vai te custar muito mais.

Se você não tiver controle de versão, também gastará um tempo excessivo fazendo backup do seu projeto e se preocupando com a versão que todos têm e qual versão está no servidor, etc.

Se você precisar convencer seu chefe, faça uma estimativa do tempo que levará para configurar e monitorar qualquer solução que não seja de versão e acrescente o custo de reescrever alguns dias de trabalho perdido. Não se esqueça de adicionar o custo da mesclagem manual de edições de 3 desenvolvedores que trabalham no mesmo arquivo de origem e o custo extra de errar a fusão. Um bom controle de versão oferece isso de graça

Em seguida, compare isso com o custo de obter o controle de versão - nulo (se você for de código aberto) e configurá-lo - 3 dias úteis.

Não esqueça que um erro posterior no projeto custará mais de um no início. Se você precisar refazer todo o projeto por causa de um erro que alguém possa cometer, isso custará muito mais do que apenas o tempo de reescrita, isso pode custar ao seu chefe a reputação da empresa.

Se você compartilhar a fonte em uma pasta, também poderá compartilhar repositórios. O chefe não saberá, exceto que há uma pasta .git lá.

Você nunca deve pedir permissão para fazer seu trabalho corretamente - Seth Godin.

Configure o controle de origem, aprenda a usá-lo e não conte ao seu chefe. Normalmente, não advogo a desobediência à administração, mas, neste caso, seu chefe está sendo estúpido. Se você realmente acha que o git levará muito tempo para aprender, comece com um sistema de controle de versão mais simplificado como o svn - ele não faz todas as coisas legais que o git faz, mas é ainda mais fácil obter um entendimento básico.

Não espere até que você esteja no meio dela e tenha sérios problemas antes de implementar alguma coisa. Basta fazê-lo e fazer o trabalho.

Editado para adicionar: O que sua pergunta realmente está perguntando é 'como faço para controlar a fonte sem usar um sistema de controle da fonte'. Você reconheceu a necessidade e acho que todo mundo aqui está realmente dizendo a mesma coisa: não há uma maneira sã de fazer o controle de origem sem um sistema de controle de origem.

Eu só tenho o seu resumo, mas a partir disso, parece que seu chefe está fazendo um argumento de tempo e dinheiro, e você está fazendo um argumento de superioridade técnica. Você precisa fazer uma discussão sobre tempo e dinheiro. Aprenda a maneira básica de fazer as coisas e acompanhe por um tempo o tempo que poderia economizar, depois apresente um registro ao seu chefe com entradas como "28/3/2011 teve que esperar 30 minutos para Joe voltar a uma compilação compilável para que pudéssemos fazer um mesclar, o comando git merge contra seu último commit seria de aproximadamente 5 segundos ", com um total agradável na parte inferior.

Se o treinamento e a configuração de um servidor são barreiras comerciais, existem inúmeras maneiras de configurar um fluxo de trabalho git, incluindo apenas um membro da equipe usando o git, com pastas compartilhadas para o "servidor".

Instrua seus colegas a copiar o código para uma determinada pasta compartilhada sempre que estiver em um bom momento para compartilhar. Você pode manter um repositório para cada um deles e fazer todo o controle de origem, além de passar lentamente cada vez mais responsabilidades de controle de origem para eles, à medida que se torna confiante o suficiente para treiná-los. Isso está longe da maneira ideal de fazer isso, mas comparado ao que você tem agora, mesmo isso poupará tempo em mesclagens. É mais fácil convencer seu chefe com menos curva de aprendizado em equipe e você obtém todos os benefícios de reversão e versão que deseja.

Não faço muito trabalho de banco de dados, mas, para meu conhecimento, a fusão de alterações no esquema do banco de dados não é muito bem tratada pelo controle de origem. Se essas fusões forem difíceis, convém considerar uma mudança de processo em que todas as alterações no banco de dados passam por um único gatekeeper.

Isso é uma loucura. Você deve usar um VCS mesmo se trabalhar por conta própria. Não usar um VCS em uma empresa deve ser proibido. Apenas faça. Agora mesmo! Realmente ... Você não precisa de coisas avançadas desde o início. O GitHub e o GitLab são muito simples de usar, mas tenho certeza de que você pode encontrar mais serviços de hospedagem compatíveis com o Windows se o seu chefe insistir (mesmo que não seja difícil de configurar e usar o Git no Windows).

O pensamento que você pede é impossível . Se várias pessoas estão trabalhando no mesmo projeto sem utilizar qualquer controle de origem, você rapidamente terá muitos problemas, e uma vez que você vai ser o principal desenvolvedor, você terá que lidar com eles.

Da minha experiência pessoal, trabalhar em um projeto sem controle de origem se torna impossível para dois desenvolvedores . Não três. Não quatro. Dois. Você provavelmente poderá gerenciar a situação com dois desenvolvedores em algumas circunstâncias excepcionais : se esses desenvolvedores forem muito organizados e profissionais, se interagirem bem, se puderem trocar facilmente (estão localizados na mesma sala nas mesmas horas, a cada hora) e se eles são capazes de evitar erros humanos (modificando por engano o arquivo que foi modificado por outra pessoa no mesmo momento e depois apagando as alterações feitas por essa pessoa).

No meu caso, sempre foi mais ou menos um desastre na hora de fazer duas pessoas participarem de um projeto sem controle de versão. Na melhor das hipóteses, uma pessoa estava enviando arquivos alterados para a segunda, e essa segunda usava uma ferramenta diff para aplicar as alterações manualmente. Nos piores casos, uma pessoa rastreava as alterações que estava fazendo e as aplicava sempre que a segunda pessoa modificava o código-fonte. Resultado: uma enorme perda de tempo, dinheiro e produtividade.

Agora, do meu ponto de vista e da minha própria experiência, vejo três soluções para o problema que você tem:

• Instale um controle de versão que seja fácil de usar . Eu costumava instalar o CollabNetSubversion como servidor SVN, é muito rápido e fácil de configurar, se você não se importa com segurança . Se você usa o Visual Studio, o AnkhSvn pode ser instalado para permitir que os desenvolvedores atualizem / confirmem o código fonte facilmente de dentro do Visual Studio.

• Convença seu chefe de que o teste de Joel é escrito por uma pessoa que conhece muito bem seu trabalho e, se o teste de Joel sugere ter um controle de versão, há uma boa razão por trás disso. Afinal, ele também pode decidir que os desenvolvedores não precisam de ferramentas de destaque de sintaxe / IDE para escrever código. O bloco de notas do Windows está ótimo, não é? E também, por que ter acesso à Internet? Tudo o que precisamos é de um PC muito, muito antigo, executando o Windows 3.1.

• Saia desta empresa , pois tenho algumas dúvidas de que tudo, exceto o controle de versão, é perfeito e profissional lá.

Não usar um VCS em um projeto maior, porque você não deseja investir o tempo de montar um é como fazer uma longa jornada descalça, porque você não quer investir o tempo de calçar sapatos.

Qualquer VCS tem ordens de magnitude melhores do que não ter nenhuma.

Uma maneira fácil de configurar um VCS é obter o TortoiseSVN (já que você parece estar usando C #, presumo que esteja no Windows). Você cria um repositório em uma pasta local que você escolher (navegue até ele, clique com o botão direito do mouse em> TortoiseSVN> Criar Repositório Aqui). Compartilhe esta pasta na sua rede (de preferência, ela deve estar em uma máquina, sempre disponível) e faça check-out com o URL file://computername/path/to/that/repository. Download excluído, não leva mais de um minuto para configurar.

Sua resposta é um link simples para o seu chefe ... envie esta página para ele e destaque o número de vezes que as palavras "sair" aparecem dos profissionais.

Embora a palavra "burro" apareça provavelmente tantas vezes, tenho certeza de que seu chefe não é. Não está claro para ele o valor absoluto disso. A pergunta a ser feita é qual pergunta relacionada aos negócios resultaria na mesma resposta (talvez um contador sugerindo "Em vez disso, não assegure que este edifício esteja vinculado ao máximo, você economizará alguns dólares!")

O controle de origem é necessário apenas onde o número de desenvolvedores em um projeto é> 0. Estou começando a pensar que se pode dizer o mesmo sobre integração contínua ...

(-:

Como vocês são desenvolvedores do ASP.NET, sugiro que você queira usar o Subversion, o TFS ou o Mercurial - mas, para ser sincero, não importa qual seja, desde que você escolha algo. Desenvolver sem controle de versão não faz nenhum sentido - ainda menos quando as ferramentas são mais ou menos gratuitas para implantar e a sobrecarga para usá-las é mínima.

O TFS oferece um nível impressionante de integração. O DVCS (mercurial ou git) provavelmente fornecerá mais flexibilidade e capacidade. Não há uma boa razão para NÃO fazer isso.

Se eu estivesse começando do zero, certamente seria com o Mercurial.

Depois de ter o controle de versão, você pode progredir para um servidor de compilação (TFS, TeamCity) e, a partir daí, para a integração contínua. Nesse ponto, você começa a ganhar a mão na mão.

Para voltar ao seu ponto de partida:

Serei o líder do projeto (gerente de projeto e desenvolvedor líder) e serei responsável por tudo

Certo, você é responsável por isso você decidir que precisa de controle de versão (porque você faz), você decidir que você precisa de um servidor de compilação (porque você faz), você decidir que você precisa ter saída destacável do seu projeto desde o primeiro dia (porque se você sempre pode implantá-lo - e, portanto, facilitar mais testes) e que a implantação será altamente automatizada - estas são as etapas que você está executando para garantir o sucesso do seu projeto (pelo qual você é responsável ...)

Como mencionado acima, você pode colocar um repositório na pasta compartilhada que você já possui. Você não precisa gastar tempo configurando um servidor se usar um sistema de controle de origem distribuído, como Git, Mercurial ou Bazaar.

Eu sugiro que você use o Git, como você já tem alguma experiência com ele, ou o Mercurial, que possui uma boa integração no Visual Studio.

Se, no futuro, seu chefe solicitar que você mude para o TFS, isso ainda é melhor do que não ter controle de versão.

Nos meus dias de Powerbuilder, tínhamos uma equipe inteira trabalhando em um conjunto de aplicativos sem usar o controle de origem. Ah, o Powerbuilder tinha controle de fonte, mas, na verdade, usá- lo foi um crapshoot - se o PB travasse enquanto você fazia o check-out de um arquivo (e travou muito), esse arquivo de código-fonte binário proprietário agora estava inacessível. Alguns sinalizadores foram definidos no arquivo e nenhuma outra cópia do PB pôde carregá-lo, mesmo a mesma pessoa que fez o check-out.

Então, o que fizemos foi bem simples. "Ei, Tom, eu vou trabalhar no xyz.pbl. Portanto, não faça alterações". No grande esquema das coisas, raramente tivemos problemas.

Supondo que você não possa convencer sua equipe a adotar o controle de versão ou que seu chefe tenha conhecimento do subterfúgio e insista para que a equipe pare, há uma abordagem menos do que ideal que você pode adotar.

Instale o Git ou Mercurial em sua própria máquina. Versão seu próprio trabalho. Quando a equipe sincronizar seu trabalho por meio do processo Beyond Compare, adicione as alterações ao seu repositório local como uma nova confirmação. Você sempre poderá recuperar uma versão de trabalho anterior do seu repositório local, caso a sincronização da equipe interrompa alguma coisa.

O uso de um DVCS garante que não há necessidade de ter um servidor e nenhum processo de configuração complexo. Instalar o Mercurial e iniciar o funcionamento com o básico não deve demorar mais que 30 minutos.

Não é uma solução ideal, mas é melhor que nada.

Minha reação inicial a isso foi que você já possui um processo de trabalho ideal sem controle de versão. Todos vocês parecem ter uma boa maneira de gerenciar a fusão e assim por diante. Do ponto de vista gerencial, essa é aparentemente uma boa situação. Eu conheci equipes que usam controle de versão, mas precisam lutar com o próprio processo de desenvolvimento.

Portanto, convencer seu chefe a basear apenas seu argumento nesse controle de versão renderia "um processo melhor" é inútil. No entanto, há outro argumento muito mais importante sobre por que você precisa usar o controle de versão ou fonte em primeiro lugar, que pode ser facilmente calculado com dinheiro. E isso é:

Risco

A questão não é que o uso do controle de origem melhora o processo de desenvolvimento. É mais um problema o que aconteceria se você não tivesse nenhum controle de origem. Quais são os riscos?

Digamos que alguém exclua por engano uma função no código ou em um arquivo inteiro? Quanto isso custaria para reparar? Espero que alguém tenha coberto isso, então a correção é marginal.

Mas o que acontece se nenhum corpo tiver um backup do arquivo perdido? Quanto horas-homem isso custaria para consertar? Talvez isso leve dias, e é facilmente calculado em média de horas-homem. Isso seria demais para a empresa? Isso poderia ser remediado de alguma forma mais rápido?

Sim, com algum tipo de controle de origem. Por outro lado: quanto tempo levaria para configurar o controle de versão e fazer o backup? A maioria dos de código aberto, como git ou mercurial, não leva muito tempo para ser configurada. Ensinar as pessoas a usá-lo não seria tão difícil, considerando que você já sabe como se fundir com o Beyond Compare e que "faz check-in" em uma pasta compartilhada. Esse é um custo de configuração único. Essas horas de trabalho seriam menores do que as que os riscos têm? Se isso for verdade, o uso do controle de origem deve ser uma prioridade.

Desde que você possa mostrar um motivo comercial, por que é útil ter controle de origem, e o gerenciamento de riscos seria um fator tão grande que convenceria a maioria dos chefes.

Use um sistema de controle de versão distribuído como o git e use sua máquina de pastas compartilhadas para armazenar o repositório de referência. Aqui está o porquê:

Cada clone é um backup

Se o disco rígido do servidor travar, todos terão uma cópia, pronta para ser implantada em uma nova unidade ou servidor. Como sua empresa não leva a sério o controle de versão, suponho que possa ser praticamente o mesmo com os backups.

Referência comum

Ter um repositório principal com uma ramificação principal permite conhecer a versão que tem a última palavra. Isso resolve o "Você testou suas alterações em relação à versão de Franck, mas você também tinha as de John? E como as fundiu?".

Entregue com mais conforto

O cliente quer uma versão alfa hoje? Bem, você pode testar se o mestre é estável o suficiente e enviá-lo. Se não estiver, e você não tiver tempo para corrigi-lo, volte no tempo e obtenha uma versão mais antiga, mas mais estável. Você não pode fazer isso se tiver apenas a versão mais recente.

Volte no tempo e corrija seus erros

Sua mesclagem manual teve problemas que você só viu depois de alguns dias, mas você já substituiu o conteúdo de suas pastas compartilhadas? Sem um CVR, você não tem histórico, portanto não pode voltar facilmente a um ponto em que pode verificar os erros que cometeu e corrigi-los. O código não é como uma imagem, é como um filme: evolui com o tempo. Você pode extrair uma imagem de um filme. Você não pode extrair um filme de uma imagem.

Localize erros mais facilmente

Um bug apareceu, mas você realmente não percebeu no momento em que foi apresentado, portanto não foi possível corrigi-lo enquanto o código estava "quente". Agora você realmente não sabe qual alteração a introduziu, portanto ela pode vir de vários locais diferentes no código. Levará horas apenas para descobrir onde procurar. Com o git, você poderia apenas desenvolver um teste para dizer se o bug ocorre em uma versão específica e usar git bissectpara encontrar o commit exato que introduziu o bug. Em vez de procurar milhares de linhas de código, agora você sabe que ele está localizado nessa alteração de 10 linhas e pode manter o teste em seu conjunto de testes para garantir que o bug não seja introduzido novamente.

Cada desenvolvedor é responsável por seu próprio trabalho

Se você é o líder da equipe e não possui VC, provavelmente terá que fazer o trabalho sujo, as fusões. Se você fizer isso sozinho, provavelmente não saberá tudo sobre todas as alterações e poderá introduzir erros. Pelo contrário, se você sempre pedir às pessoas que escreveram o código que se reúnam sempre que houver código a ser mesclado, é hora de elas não usarem para produzir um novo código.

Com um VCS, em um fluxo de trabalho simples, o desenvolvedor precisa apenas cuidar de seu trabalho e de uma fonte externa de mudanças: a ramificação principal. Pode haver 1 ou 100 pessoas se comprometendo no ramo mestre, é o mesmo. Para poder promover suas alterações, ele / ela precisará adaptá-las às últimas alterações feitas por outras pessoas. Pode parecer que leva mais tempo para enviar código, mas isso é porque você também está fazendo a mesclagem que levaria tempo de qualquer maneira.

A diferença é que a mesclagem é feita pela pessoa que fez as alterações, que conhece melhor o código porque ele o escreveu.

Quem escreveu esse código?

Há esse bug aqui, mas quem escreveu essa linha de código específica? É difícil lembrar, principalmente se o projeto durar vários meses. git blameteria lhe dito quem e quando essa linha foi escrita, para que você possa perguntar à pessoa certa, e não há "não me lembro de escrever isso".

O projeto está ficando maior

O cliente deseja mais recursos e você é uma equipe pequena demais, precisará de outro desenvolvedor. Como você gerencia a maior complexidade de mesclagem sem um VSC?

Mudanças urgentes

O cliente ligou e solicitou uma correção crítica de bug para a produção, mas você estava trabalhando em um novo recurso. Apenas git stashpara deixar suas alterações de lado, ou enviá-las para uma nova ramificação e enviá-las, você estará pronto para começar a trabalhar com a correção urgente, sem medo de perder seu trabalho pendente.

Funcionou 10 minutos atrás

Você está fazendo algumas alterações localmente e algo que funcionou 10 minutos atrás parou de funcionar. Sem um VCS, você olha fixamente para o código ou, na melhor das hipóteses, faz uma cópia da versão de referência e difere para ver o que muda. Ah, espere, a referência mudou desde que comecei a trabalhar, então não posso mais diferenciar. E não pensei em manter uma cópia original do código em que baseei minhas alterações.

Com um VCS, você simplesmente faz algo como git diffimediatamente e altera as alterações em comparação com a versão correta do código em que se baseia.

Eu tenho que manter meus logs de depuração

Então você é um cara mau e não usa log? Você teve que borrifar printfs em toda a sua base de código até encontrar todas as partes daquele bug desagradável? Agora você encontrou um, corrigiu-o, mas deseja manter seu código de depuração cuidadosamente criado para corrigir os problemas restantes.

Sem um VCS, você precisa copiar os arquivos, expurgar o código de depuração (que pode adicionar alguns erros de edição), enviar por push e colocar de volta os arquivos de backup. Ah, mas parece que algum código de depuração chegou de qualquer maneira.

Com o git, você apenas git add --patchseleciona as poucas linhas de código que deseja colocar no seu commit e pode confirmar apenas isso. Então você retoma seu trabalho e ainda possui seu código de depuração. Você não precisou tocar no código; portanto, não há erro de copiar / colar.

A grande bola de lama

Sem um VCS, as pessoas trabalham do lado deles e oferecem várias alterações, às vezes não relacionadas. Quando há muito código para verificar, é difícil encontrar um bug.

Um VCS permitirá que você faça pequenas alterações incrementais, além de fornecer um registro de alterações. O registro de alterações é essencial: as pessoas devem dizer por que estão fazendo a alteração, não o que é a alteração (a pergunta que já está respondida pela própria alteração de código). Isso significa que, ao inspecionar algum código de um novo recurso, por exemplo, você não precisará ler muitas alterações mistas não relacionadas, como correções de erros não relacionadas. Isso ajuda a focar no código de seu interesse.

Se eu der 100 batatas 1 por 1 e uma estiver podre, você a encontrará imediatamente. Agora, se eu jogar 100 batatas na sua frente e pedir que você encontre a podre, essa não é a mesma tarefa.

Indentação

Espero que você tenha uma boa política de estilo de codificação, caso contrário, as mudanças de recuo o deixarão louco se você mesclar manualmente. Claro, você pode ignorar o espaço em branco nas alterações (mas não nos idiomas quando a indentação conta, como Python). Mas você terá um código de aparência estranha difícil de ler.

Você é o líder do projeto

Se você é o líder, isso significa que você será culpado se as coisas não funcionarem. Se você não se sentir confortável com a situação porque seu chefe ainda não consegue entender que vale a pena usar a ferramenta certa para o trabalho certo, então, pelo menos, eu me recusaria a me tornar o líder de uma falha previsível.

Use o dropbox, ele possui histórico de versão automático. Você pode compartilhar a pasta dropbox entre vários usuários.

Editar

Você também pode baixar o TortoiseSVN-client e criar "repositório local" na unidade de rede. Em seguida, as pessoas podem fazer check-out do código fonte pelo local da pasta da rede.