Passando de um projeto individual para um projeto de equipe no futuro. O que devo fazer agora em preparação e o que pode esperar?

Para elaborar, estou interessado em saber o que as pessoas pensam que você precisa implementar enquanto ainda é um projeto individual (controle da fonte da equipe, documentação, compilação etc.) e o que as coisas não precisam ser feitas até que a segunda pessoa chegue. para o projeto.

Qualquer pessoa com alguma experiência em percorrer esse cenário, suas idéias serão apreciadas.

O que eu aprendi. (Tentei uma ordem diferente. Eu estava errado. Essa é a ordem na qual as coisas se tornam relevantes.)

1. Coloque tudo no controle do código-fonte. Use algo a que todos tenham acesso e comece agora . Sem exceções. Sem atrasos. Sem desculpas.

2. Crie uma área de controle de qualidade / teste totalmente separada do seu ambiente pessoal de "trabalho" ou "desenvolvimento". Pelo menos um ID de usuário separado. Idealmente em uma VM separada.
   Completamente separado. Não há sobreposição possível com o seu ambiente de trabalho atual.

3. Pare de testar além do teste de unidade em seu próprio ambiente de trabalho. Teste de código e unidade que você faz "como você". Todos os outros testes (integração, desempenho, qualquer que seja) que você faz na VM separada. Nunca teste como você. Sempre teste como um usuário de controle de qualidade separado. Idealmente em uma VM separada.

   "Funciona para mim" é uma coisa ruim a dizer aos membros da sua equipe. Muito mal. Você precisa descobrir o que eles estão fazendo de errado. Várias vezes ao dia.

4. Planeje anotar tudo. Use uma ferramenta de marcação de texto sem formatação (RST ou Markdown ou algo assim) para que toda a documentação seja texto sem formatação no repositório de controle de versão. Uma ferramenta pode criar páginas HTML (ou seja, Docutils for RST) ou PDF ou o que parecer melhor. Não use formatos de documentos proprietários (ou seja, MS-Word). Eles podem não funcionar bem com alguns sistemas de controle de código-fonte.

5. As primeiras coisas que você precisa anotar são as seguintes.

   • Como criar um ambiente de desenvolvimento de trabalho. Em caso de dúvida, crie uma máquina virtual e faça toda a operação nessa máquina virtual. Verifique se as etapas realmente funcionam e se a documentação está clara . Linhas reais digitadas no tipo de clareza real da linha de comando.

   • Como executar o conjunto de testes de unidade. Novamente. Certifique-se de que as instruções funcionem e não exijam reflexão. "Digite isto:" "Confirme que:" tipo de coisa. Não é que os membros da sua equipe sejam estúpidos. É que você não se lembra do que está assumindo, a menos que escreva tudo.

   • Como executar o conjunto de testes de integração.

   Não perca muito tempo descrevendo a arquitetura ou os princípios de design. Você precisa colocar alguém em funcionamento primeiro. Você pode explicar as coisas mais tarde.

6. As próximas coisas a serem documentadas são as histórias de usuários. E os casos de teste que suportam essas histórias. E os acessórios de dados necessários para os casos de teste que suportam essas histórias de usuários.

   Você estará compartilhando isso. Ele fica sob controle do código fonte.

7. Eventualmente, você pode documentar as outras 4 visualizações.

   • A visão lógica é algo útil para documentar. As imagens são aceitáveis ​​aqui. Isso tende a evoluir rapidamente, portanto, não perca tempo capturando as informações herdadas. Crie uma maneira de cooperar com os membros da sua equipe.

   • A visualização do processo geralmente é útil. Depende da aplicação geral como isso é importante.

   • A visão de desenvolvimento - módulos, bibliotecas, estruturas etc. - é frequentemente descrita informalmente. Uma imagem pode ajudar, mas é notoriamente difícil fazer isso completo o suficiente para que alguém possa pegar um documento e fazer cara ou coroa. Mesmo projetos públicos há muito estabelecidos têm documentação de biblioteca que é simplesmente ignorada. (Levando a muitas perguntas sobre estouro de pilha.)

     Além de ser aceitável por ser informal, isso tende a mudar rapidamente.

   • Informações de implantação. Servidores. Endereços IP. Credenciais de banco de dados. Todo esse material deve ser anotado. Eventualmente.

Ferramentas e metodologia

O que é necessário para colaborar com sucesso e ser produtivo?

• Identifique partes / componentes do seu projeto: distinguindo claramente entre diferentes partes (banco de dados, camada de acesso a dados, site, serviço, API, projetos de teste, scripts de construção, ...) e ambientes (desenvolvedor, teste, produção) e nomeie-os tem um impacto consistente na sua comunicação oral e escrita (documentação, nomes de projetos, ...)
• Use um sistema de gerenciamento de código-fonte (caso ainda não o tenha). Pense em como usar a ramificação em seu projeto e configuração.
• Automatize suas construções - facilite ao máximo a configuração de um ambiente a partir do seu repositório de origem.
• Projetos de teste são obrigatórios em grandes projetos, pelo menos nos projetos mais complexos.
• Use o ambiente de preparação onde seu projeto está pronto para ser usado. Além disso, crie e mantenha dados de amostra para uma configuração de preparação automatizada.
• Use um sistema de rastreamento de erros que possa ajudar a priorizar e planejar o desenvolvimento, e também sirva como memória para erros passados ​​e como eles foram resolvidos.
• Documente cada parte do seu projeto, algumas mais que outras. Eu pessoalmente gosto: Visão geral - Arquitetura - Dependências - Configuração - Problemas comuns ( daqui ). Às vezes, menos é mais - para não deixar sua documentação desatualizada, é melhor ser conciso e deixar que a documentação se torne parte de sua atividade cotidiana.

Gerenciamento / trabalho em equipe

... ou qualquer outra coisa no nível interpessoal

• Defina suas expectativas do outro desenvolvedor. Seja razoável, é provável que ninguém traga o mesmo envolvimento e paixão que você - pelo menos não desde o início. Comunique o que você espera e o que não, defina suas responsabilidades e as de outras pessoas. Nem todo mundo é engenheiro, arquiteto, desenvolvedor, dba e sysadmin, mas se é isso que você está procurando, escolha a pessoa certa ou ficará desapontado.
• Inicialmente , defina as tarefas com precisão e revise e discuta os resultados. Gradualmente, inicie cada vez menos microgerenciamento. A idéia é criar confiança e aumentar a responsabilidade.
• Planeje seu projeto , defina metas para ele e para sua equipe para o próximo ano. Escreva e verifique mais tarde, isso dará uma perspectiva . Esses objetivos podem ou não ser comunicados a outras pessoas (contanto que sejam metas que você precisa alcançar, e não outras), pode ser simplesmente sua própria lista de verificação.
• Reserve um dia para preparar e planejar o primeiro mês (ou dois / três meses) do seu novo desenvolvedor. Acho extremamente motivador ao trabalhar com pessoas bem preparadas. Ninguém deve ter a impressão de que seu tempo é desperdiçado.
• Deixe ir . É o seu bebê, ele deve se tornar o de outra pessoa também. Permita que o outro se torne um especialista melhor que você, pelo menos em algumas partes do projeto. Isso significa que você conseguiu.
• Escute - se você a contratou, ela tem algo a dizer. Esteja pronto para aprender.
• Esteja pronto para compartilhar seu conhecimento e experiência (e, portanto, seja paciente).
• Erros serão cometidos, é como eles são tratados e o que todos estão aprendendo sobre eles o que conta.
• Reserve tempo para aprender e experimentar

Referências de livros

Vou listar alguns dos livros mais mencionados que realmente li e acho que valem a pena ser lidos, para uma descrição mais detalhada ou para mais livros, você pode conferir algumas das perguntas sobre SO que fazem exatamente isso, como esta ou esta pergunta.

Vale a pena ler esses livros em relação a equipes, organizações e projetos de programação:

• Peopleware
• Mítico Homem Mês
• Estimativa de software, desmistificando a arte negra

Nenhum deles é um guia prático de como implementar a metodologia X (exceto estimativa de software, este livro ajuda a escolher um processo de estimativa apropriado). Obviamente, livros mais focados em programação como o Code Complete também são muito enriquecedores.

Vou falar da experiência, mas tenha em mente que todos são diferentes. Essas coisas não são universais.

Uma coisa é deixá-lo ir pessoalmente. Esse projeto é algo com o qual você viveu e viveu por 18 meses - você naturalmente gostaria que todas as mudanças fossem como você faria. Dê um buffer para um colega cometer erros e aprender. Crie uma sala para eles serem úteis. E lembre-se de que isso pode não acontecer imediatamente. Além disso, seria ótimo se houver algo, parte do código que eles possam sentir que conseguem melhorar ou criar, que pareça um sucesso em um curto período de tempo. Paciência e tolerância têm uma boa taxa de retorno aqui. Não tente microgerenciar, e se você quer criticar, dizer "você está errado", certifique-se de ter um mérito, você pode provar isso, não é uma luta "religiosa".

Outra questão importante é encontrar a pessoa certa para você. Idealmente, é melhor encontrar alguém mais inteligente que você. É subjetivo e relativo, mas se você sente que uma pessoa tem algum conhecimento e habilidades que não possui, é o melhor. Será uma colaboração mutuamente gratificante.

Há duas maneiras: o colega será uma chatice e você acabará refazendo o que fez ou as habilidades de dois se multiplicarão, e não apenas se somarão, e você realmente gostará de trabalhar juntos.

Em um tópico de "código limpo, rápido e reutilizável" - sugiro que em uma entrevista peça para escrever um pequeno micro-kernel / gerenciador de serviços e / ou executor de tarefas. Veja como os componentes conectáveis ​​são especificados e configurados. Não precisa ser finalizado, é um pensamento que conta. E você também aprenderá rapidamente que as pessoas que sabem como fazê-lo vão querer dinheiro decente ;-) Boa sorte!

Minha opinião: comece com um documento da arquitetura do seu projeto interno para alguém ... que não esteja ciente disso. Tente explicar quais premissas estão em vigor e quando / onde você se desviou das práticas comuns e por quê.

Automação de compilação: ótima idéia, posso adicionar a automação de configuração para uma máquina de desenvolvimento. Quanto mais fácil for a construção, mais ela será (mais / mais rápida implantação de testes).

Outra idéia (isso me ajudou muito uma vez): peça ao novo desenvolvedor que faça algumas tarefas de limpeza em pequena escala em diferentes áreas da sua base de código, para que ele se acostume com as ferramentas de layout, etc. Uma boa idéia é remover áreas obscuras que podem adicionar confusão posteriormente (exemplo: se você usou o emmm python para duas linhas de um script de shell em algum lugar e seu projeto é baseado em java, solicite que essas duas linhas sejam reescritas em java, para que o desenvolvedor nº 3 precise saber menos para trabalhar)

Eu me concentraria em automatizar tudo o que requer trabalho manual e, portanto, pode ser ferrado por uma pessoa inexperiente . Que, com base no seu breve comentário acima, inclui o seguinte:

• instale o controle de versão e substitua os backups manuais pelos automatizados,
• configure a implantação automática o máximo possível (no mínimo, escreva um script para implantar via FTP em vez de fazê-lo manualmente.

Se você não conseguir fazer isso, será acorrentado para executar essas tarefas para sempre, ou (alguns) os novos caras inevitavelmente estragarão algo mais cedo ou mais tarde.

A outra tarefa importante é, como observou @dimitris, documentação. @S. Lott acrescentou muito mais detalhes sobre isso, então apenas marque com ele um +1 em vez de repetir :-)

Aqui estão alguns pensamentos, parcialmente baseados na experiência pessoal:

• Documente seu projeto. Especificações de projeto, diagramas, manuais e comentários ajudarão o novo funcionário a se atualizar. Explicando um sistema complexo única verbalmente pode provar lento e frustrante. A documentação é frequentemente negligenciada em projetos individuais. Verifique se o seu é uma exceção.

• Primeiramente, concentre-se no código de nível de API / núcleo, fornecendo ao novo funcionário algum trabalho na "camada de aplicativos" ou correção de erros para familiarizá- los gradualmente com o código. Geralmente, começa com mais fáceis , ainda significativos e, assim, recompensar tarefas .

• A comunicação é importante. Responda às perguntas, comentários e idéias do novo funcionário. Explique por que você acha que uma ideia não é boa se você o faz. Um novo par de olhos pode identificar surpreendentemente bem o espaço para melhorias. Se o seu novo funcionário for decente, ele poderá revisar seu código por pares e, eventualmente, participar de decisões de arquitetura. Discutam, refletem idéias um sobre o outro. Esse é um dos maiores benefícios de ter um colega de trabalho em seu projeto.

• Defina responsabilidades claramente , depois de saber que tipo de tarefas o seu novo membro da equipe está fazendo. Estabeleça práticas de documentação e convenções de codificação para manter as coisas tranqüilas.

• Use um sistema de controle de revisão . Mantenha um layout de arquivo de origem lógica e construa disciplina .

Quanto à entrevista - não sou muito fã de testes de codificação artificial ou de perguntas complicadas, a menos que você queira experimentar a capacidade de suportar o estresse do candidato. Mesmo o mais inteligente dos solucionadores de problemas pode ficar preso nessa situação. As qualidades que você procurará, entre outras, são: honestidade , capacidade profissional , conhecimento / insight tecnológico , entusiasmo e compatibilidade mútua . Ambiente de trabalho pode significar muito; não é aconselhável escolher um companheiro de equipe que você não goste. Coloque suas perguntas corretamente e faça uma discussão informal para obter uma boa imagem do seu candidato. Boa sorte!

Tecnologia

Se você está trazendo alguém como desenvolvedor, há três coisas principais que eu recomendaria que funcionassem antes de começarem.

1. Fonte de controle
2. Rastreamento de problemas
3. Integração contínua

Se essas três coisas estiverem funcionando corretamente, você eliminará cerca de 75% do problema comum que ocorre quando você traz um novo membro da equipe. O objetivo dessas peças de tecnologia é pegar muito do que está acontecendo apenas em sua cabeça e colocá-lo fora onde seu membro da equipe possa interagir com ele.

O controle de origem garante que ambos estejam trabalhando na mesma coisa. O rastreamento de problemas ajuda você a acompanhar o que precisa ser feito e facilitará o conhecimento do que eles estão trabalhando e realizando. A integração e o teste contínuos ajudarão a garantir que você tenha um processo de compilação repetível e que novas melhorias não estejam quebrando outras partes do código.

Pragmatic Programmer tem alguns livros muito bons sobre isso. Aqui estão alguns que eu recomendaria. Eles têm outros títulos semelhantes com base em qual linguagem de programação você está usando ou em qual controle de versão você deseja usar:

http://www.pragprog.com/titles/tpp/the-pragmatic-programmer http://www.pragprog.com/titles/tsgit/pragmatic-version-control-using-git http: //www.pragprog. com / títulos / auto / pragmatic-project-automation

Pessoal

Muitas vezes, as dificuldades que você enfrentará são menos no lado técnico das coisas e mais no aprendizado de deixar o lado de lado. Pode ser difícil dar a outra pessoa o controle sobre os aspectos do projeto - especialmente se você está acostumado a fazer tudo sozinho e a tomar todas as decisões. Você se poupará de tristeza se encontrar uma área em que possa fazer com que a nova pessoa trabalhe com uma quantidade razoável de liberdade no início, a fim de desenvolver uma base de confiança. Se você contratar uma boa pessoa, provavelmente aprenderá como confiar na outra pessoa para fazer um bom trabalho, mesmo que todas as decisões individuais não sejam as mesmas que você teria feito.

Você deseja dar ao seu novo contratado a liberdade de resolver problemas da maneira que funciona para eles, mantendo as salvaguardas em vigor para que você possa detectar problemas desde o início.

Estes pontos são mais importantes na minha opinião:

1. Leia sobre partes cruciais do seu código e verifique se elas são fáceis de entender. Use comentários ou funções intuitivas e nomes de variáveis.
2. Facilite para a nova pessoa enviar código.
3. Se não for trivial, crie um arquivo README que explique todas as etapas necessárias para o novo desenvolvedor em como configurar o ambiente de desenvolvimento. Como alternativa, ajude de perto na configuração desse ambiente.
4. Dê ao novo desenvolvedor tarefas claramente definidas ao trabalhar nesse novo projeto. Na minha opinião, essas tarefas devem envolver funcionalidades novas, porém simples. As tarefas de limpeza não fazem muito sentido na minha opinião, pois o novo desenvolvedor precisa se acostumar com o seu estilo de codificação e com os hábitos dele, mesmo que sejam ruins. Limpar ou mesmo refatorar são tarefas que precisam ser realizadas por pessoas que conhecem o código.
5. Esclareça qual é o processo de envio de código. (Por exemplo, envie apenas coisas que sejam compiladas.) Mas não seja muito rigoroso, isso pode ser frustrante no começo.
6. Tenha um documento com convenções de codificação pronto. Pode ser realmente frustrante adivinhar quais são as outras convenções de codificação.
7. Se o aplicativo for complexo, tenha alguma documentação pronta explicando a arquitetura. Ou explique a arquitetura para a nova pessoa usando fluxogramas ou algo semelhante. Você não quer que o novo desenvolvedor perca muito tempo na engenharia reversa do seu projeto.
8. Se o novo desenvolvedor deve fazer implantações sozinho, tenha uma lista de verificação ordenada pronta explicando todas as etapas necessárias para implantar.

E por último mas não menos importante: obtenha um sistema de controle de versão. Subversion está bem. Mas lembre-se de não adicionar os arquivos Eclipse (ou qualquer outro) que sejam específicos do usuário e, portanto, estejam constantemente em busca. Eles fazem você perder horas. Não hesite em perguntar no Stackoverflow se tiver problemas com ele.