Como implementar um processo de desenvolvimento com estudantes universitários

No meu primeiro trabalho como desenvolvedor de software, minha equipe usou o agile / scrum para gerenciar o fluxo de trabalho do projeto e funcionou muito bem. Tive alguns mentores experientes que me colocaram no caminho certo - devo-lhes uma grande dívida de gratidão. Eu trabalhei lá por alguns anos, depois mudei para uma nova oportunidade alguns meses atrás.

Avanço rápido para o meu trabalho atual. Eu trabalho em uma universidade sob a direção de um professor. Como estou na universidade, quase todo programador é estudante (eles são baratos e abundantes!) Meu chefe tem experiência em gerenciamento, mas não com desenvolvimento de software, e a equipe de software nem sempre está na vanguarda da mente do meu chefe . Estas condições criaram o ambiente perfeito para a criação de alguns muito software de má qualidade. Os projetos de software parecem um pouco desonestos, não pensam em projetar e empregam práticas verdadeiramente assustadoras. Eu sei que as coisas poderiam ser melhores.

Quero implementar um processo de desenvolvimento para ajudar todos a acompanhar, aumentar a qualidade do código e implantar software mais estável. Só não sei por onde começar.

Estou não olhando, por assim dizer, por respostas como "Use Scrum", "Configurar uma placa de kanban", ou "Dê uma olhada ágil!" (embora as idéias sejam apreciadas). Mais especificamente, espero obter informações sobre como implementar um processo de desenvolvimento para este ambiente de trabalho. Os funcionários geralmente trabalham entre 1 e 2 anos antes de seguir em frente, geralmente são inexperientes e as reuniões stand-up diárias que incluem todo mundo são quase impossíveis de agendar.

Como alguém promove qualidade, eficiência e comunicação em um ambiente de trabalho assim?

Atualização: Depois de ler algumas das respostas e comentários, pensei em fornecer mais informações.

Eu não me consideraria um mestre na arte do desenvolvimento de software, mas tenho experiência suficiente para reconhecer má programação quando a vejo. Posso determinar se um desenvolvedor é talentoso ou não depois de passar apenas um ou dois minutos trabalhando com eles. Estou confortável com minhas próprias habilidades para encontrar uma maneira de resolver um problema de maneira inteligente ; no entanto, a área em que realmente tenho falta de experiência é o gerenciamento de projetos em que outros desenvolvedores estão envolvidos (e é por isso que estou aqui pedindo a todos vocês pessoas maravilhosas adendo).

Eu fiz parecer que todo aluno que entra neste escritório é um completo idiota. Houve alguns ovos ruins aqui, mas a maioria dos estudantes que conheci é inteligente, quer aprender e apaixonada pelo trabalho. Alguns estão apenas começando, e não sabem o que não sabem. E tudo bem. Quando comecei a programar, não estava em melhor forma!

Leva mais tempo para limpar um erro do que para verificar previamente. Se você estiver lidando com desenvolvedores que (possivelmente) não são qualificados ou desconhecem as boas práticas, isso significa que eles não poderão alterar a base de código (principal) até que seu código seja examinado por alguém experiente.

Como você não queria uma explicação das metodologias, deixe-me examinar essa parte: use tarefas ágeis para configurar diferentes recursos que podem ser desenvolvidos independentemente.

Comece a usar ramificações de recursos, para que todos trabalhem em uma ramificação separada. Quando uma tarefa é concluída, o desenvolvedor não pode mesclar seu código à ramificação principal. Se você estiver usando o Git, eles ainda poderão iniciar uma solicitação de recebimento. Caso contrário, use qualquer método de rastreamento de tarefas concluídas (/ branches) que mais lhe agrade.

Então chegamos ao processo de revisão . Sua pergunta é um pouco vaga: se também há desenvolvedores experientes cujo julgamento pode ser mais confiável do que o dos alunos. Então deixe-me elaborar de qualquer maneira:

Se houver desenvolvedores experientes, encarregue-os de revisar o código das tarefas concluídas. Se estiver bom, eles podem mesclá-lo no ramo mestre. Caso contrário, eles podem refatorar ou dar feedback ao desenvolvedor sobre o que precisa ser aprimorado.

Se não houver desenvolvedores experientes, você sempre terá problemas. Se não houver ninguém que identifique código bom a partir de código incorreto, é impossível manter a qualidade do código.
O melhor que você pode fazer é realizar reuniões de revisão, nas quais os desenvolvedores apresentam e explicam sua implementação na frente dos outros desenvolvedores. Embora isso não possa garantir a prevenção de todos os problemas (por exemplo, se todos os desenvolvedores tiverem o mesmo conceito errado sobre boas práticas, ainda assim evitará a maioria dos problemas (por exemplo, se pelo menos um desenvolvedor tiver a idéia certa e puder articulá-la; ou quando o problema persistir) de desenvolvedores que entendem o problema de maneira diferente)

Como alguém promove qualidade, eficiência e comunicação em um ambiente de trabalho assim?

• Qualidade - revise o código por desenvolvedores experientes. Na ausência de desenvolvedores experientes, faça uma revisão em grupo para, pelo menos, cobrir suas bases da melhor maneira possível.
• Eficiência - Se você definir as tarefas independentes corretamente, minimizará as pessoas que precisam esperar umas pelas outras. Em um ambiente em que nem todos estão disponíveis ao mesmo tempo, presumo que você esteja lidando com muitos atrasos na espera da pessoa A. Acompanhe os desenvolvedores que não estão progredindo, apenas para verificar se precisam de ajuda ou apenas permitir que eles desabafem suas frustrações (essas frustrações podem revelar conceitos errôneos sobre problemas evitáveis).
• Comunicação - Defina uma política de portas abertas para que os desenvolvedores possam pedir ajuda, feedback ou inspiração a alguém. Na ausência de um mentor qualificado, tente facilitar a interação da equipe (é claro que você ainda pode fazer isso mesmo se tiver um mentor disponível, mas a importância de fazê-lo aumenta na ausência de um mentor). Especialmente em uma situação em que as pessoas trabalham remotamente e em horários diferentes, os desenvolvedores geralmente não estão próximos de seus colegas de trabalho e tendem a não se comunicar. Mesmo um punhado de reuniões sociais pode fazer maravilhas para melhorar a comunicação relacionada ao trabalho em outros momentos.

A principal coisa para esse tipo de ambiente em que as pessoas são novas e provavelmente saem são as revisões obrigatórias de código.

Eles ajudam a espalhar o conhecimento do que deve ser feito. Eles ajudam a impedir que o pior código entre na base de código. Eles promovem consistência na implementação.

Porque com tanta rotatividade e inexperiência, a comunicação é mais importante do que costuma ser.

Mais uma ideia do que uma solução, mas encontre uma seção crítica da base de código que contém recursos e elementos semelhantes aos projetos que seus alunos desenvolvedores podem fazer e faça uma limpeza MUITO bem. Um grande problema com os novos desenvolvedores é que eles não conhecem as normas e convenções da base de código e analisam outros códigos para ter uma idéia de como configurar seus próprios. Ter muitos desenvolvedores novos trabalhando em uma base de código bagunçada significa que eles verão a bagunça e acharão aceitável ou a melhor maneira de fazer as coisas. As más práticas se perpetuam mesmo em um ambiente de alta rotação.

Por ter pelo menos uma seção de código primitiva e bem escrita (ou mesmo apenas um arquivo), você pode dizer aos desenvolvedores de seus alunos que a usem como um exemplo de práticas recomendadas. Diga a eles que você ficará emocionado se eles puderem escrever código semelhante a esse e que grande parte do outro código pode não ser um bom exemplo da maneira correta de fazer as coisas.

Adicionar comentários ou outra documentação com uma explicação de por que as coisas são feitas de uma certa maneira também ajudará os novos desenvolvedores a acelerar mais rapidamente com as melhores práticas de código.

Integração Contínua -

Essa é uma estrutura prática e conceitual para implementação incremental e flexível de ferramentas, habilidades e processos de equipe.

O IC é a ideia de um fluxo de trabalho da gravação de código para a implantação. Essas tarefas são conceitualmente e realmente independentes.

CI é automação, em particular. Isso tem implicações profundas em qualidade e produtividade, começando no ponto em que o código é digitado na tela.

• A implementação da tarefa de IC pode ser tratada de forma independente, em detalhes e simultaneamente. O foco pode mudar conforme necessário.
• Não introduza uma ferramenta de CI de sopa para nozes
  • Vocês serão distraídos pelo processo e tenderão a branquear as habilidades-tarefa encapsuladas.
• Introduzir as coisas rapidamente

• Espere ser o agente de mudança em tempo integral. Torne-se o líder; não apenas um gerente, não apenas o codificador sênior.

• Seja estratégico

  • O Santo Graal da CI é um hands-off compilado para automação de implantação. Eles não podem FUBAR se não puderem tocá-lo.
  • Treinamento e materiais de treinamento.
    • Documentar processos.
    • Crie um manual do programador , deixe-o evoluir organicamente.
    • Obrigatório.
    • Esboços de exploração visando habilidades específicas e a própria base de código.
  • Instale valores de programador profissional, como:
    • TDD absolutamente cria qualidade
    • As revisões de código incluem todos os artefatos: comentários, código comentado, testes de unidade etc.
    • "Estou envergonhado com quantos erros foram encontrados"
    • A objetividade não é sufocada pelo senso de propriedade do código pessoal e pelo medo de "ofender" o proprietário.

• Seja tático

  • As tarefas discretas de IC podem ser automatizadas, por exemplo, uma confirmação de controle de versão acionando testes de compilação e de unidade.
  • Regras aplicadas à automação, como formatação de código.
    • Cuidado com demasiadas minúcias pedantes. A ferramenta começará a ser ignorada. Module a imposição de regras para que não seja esmagadora.
  • Implemente o Desenvolvimento Orientado a Testes imediatamente
  • Priorize e enfatize cada mudança
    • Não presuma que os pulos de conhecimentos e habilidades principais simplesmente ocorram.
  • Não permita que a urgência subverta a implementação adequada
  • Lidere a mudança e siga
    • É necessária orientação para novos caras e algum treinamento mínimo.
    • Treinamento explícito e orientação inequívoca para coisas novas
    • Treine pelo menos alguns padrões mínimos e nocionais. Não precisa ser formal, mas uma caminhada aleatória pelo YouTube não é treinamento. Verifique pessoalmente - novamente evite a formalidade.
  • Seja o revisor do código, revise todo o código.
    • Guie explicitamente correções de bugs desafiantes e compartilhe experiências de aprendizado notáveis.
  • Flexibilidade rígida. Desculpe, tive que dizer. Mas é verdade.
• Criar cultura
  • Ter expectativas profissionais
  • Padronizar ferramentas
  • Enfatize o aprendizado sobre as métricas de produção
  • Seja um mentor
  • Ao introduzir a mudança, simplesmente dependendo da iniciativa dos indivíduos "para fazê-lo" subtilmente subverte o desenvolvimento da equipe. A identidade de uma equipe coesa inclui seus elementos comuns: ferramentas, conhecimento e nível de habilidade. O respeito mútuo cresce na medida em que cada membro adota teses como valores dignos. O líder da equipe é o modelo, é inevitável; não modele uma atitude e expectativa "qualquer que seja".

O caminho para a qualidade

• Teste de unidade

  • chave para o desenvolvimento orientado a testes
    • Não é necessário ler livros inteiros sobre isso
    • Isso deve se tornar o paradigma de codificação
    • Como líder, você deve se manter atento até que todos dêem o "salto de fé nos testes unitários". Essa mudança de paradigma de "Estou escrevendo o dobro do código!" para abraçar sua incrível produtividade.
  • O teste de unidade era obrigatório em nossa loja. Mas muitos não fizeram isso porque não queriam. A falta de convicção da gerência enviou a mensagem de que os testes de unidade não funcionam realmente.
    • Portanto, os testes de unidade eram frequentemente ignorados durante as revisões de código, permitindo testes errados, ineficazes e com erros na base de código. O teste unitário lackadasical destruirá todo o esforço.

• Controle de versão

  • Eu colocaria isso em primeiro lugar, mas o teste de unidade é mais fácil de começar
  • não atrase outras iniciativas porque o controle de versão não é tão fácil
  • Faça um plano de controle de versão.
    • Você deve anotá-lo.
    • Faça isso mesmo que seja tão simples quanto "jogue tudo no porta-malas e sem ramificação".

• Revisões de código

  • Isso tem o maior potencial para melhorar a qualidade do código em detalhes.
  • Use um processo de revisão 2.
    • Fiquei muito surpreso com quantos erros uma segunda revisão captura.
    • Confie mas verifique. Execute o código. Por que você deveria dizer isso? Veja imediatamente acima.
    • Inicialmente você será o único revisor. Faça com que a equipe assista você rever "ao vivo". Eles nunca aprenderão a pensar o contrário.
    • Em breve você será apenas o segundo revisor. Conforme as habilidades individuais o exigirem, revise-as; eventualmente os dois revisores. É claro que você sempre estará olhando o código, sem exceção.

• Reestruturação

  • Esta é uma disciplina formal distinta.
  • Refatoração: aprimorando o design do código existente por Martin Fowler
    • Receitas de refatoração codificadas que garantem a alteração do código livre de erros induzidos.
    • Comece uma biblioteca profissional com este livro.
  • Formalidade à parte, introduza-a ad hoc através de revisões de código

• Capture seu ambiente

  • Configurações da ferramenta de linha de base: controle de versão, IDE, ferramenta de CI, SO, etc.
  • O código fonte, a documentação e as configurações devem ser sincronizadas no controle de versão.

Uma palavra sobre processo

Ágil (e seus subgêneros como Scrum): Esqueça. "Você é ágil, não é ágil." Veja isso por Dave Thomas, um dos signatários originais do Manifesto Ágil .

• A Corrupção do Ágil - Entrevista do Dr. Dobbs Journal
• O Agile está morto (vida longa, agilidade)
• O Agile está morto - Uma palestra de conferência.

Dadas equipes pequenas e inexperientes, meu senso de aranha se apaga quando vejo ferramentas de integração de equipes como o Visual Studio Team Services. Minha experiência é limitada aqui, mas sinto uma imposição rígida, supérflua e rígida. Sei que muitos usam essas coisas com grande efeito, mas cuidado com o potencial de comprar uma solução procurando um problema.

Uma palavra sobre ferramentas

Apenas eu. Não daqueles "Melhores ferramentas de software agora ...", potes de isca de clique.

Jenkins

Uma ferramenta de integração de IC. Baseado na Web, amplamente utilizado. Essencialmente, por meio de uma GUI da Web, você configura e automatiza as várias tarefas e ordem de execução, como compilação, execução de testes de unidade e atualização do controle de versão. É muito simples, portanto é favorável ao seu ambiente de CI nascente.

Controle de versão

Eu prefiro Mercurial do que Git. Esta postagem do blog foi o motivo pelo qual eu escolhi o Mercurial: Git é MacGyver, Mercurial é James Bond

Subversion é bom. O Mercurial & Git tem uma arquitetura diferente, superior à do Subversion.

Ambiente de desenvolvimento integrado

Aqui está uma grande consideração se todos usarem diferentes ferramentas de codificação: não existe algo como texto sem formatação

Uma palavra sobre uma biblioteca profissional

A internet é ampla, rasa e desorganizada.

• Code Complete por Steve McConnell
  • Faça todo mundo ler o terço do meio.
  • Tem um apêndice de livros profissionais sugeridos.
• Refatoração: aprimorando o design do código existente
  • Receitas de refatoração codificadas que garantem a alteração do código livre de erros induzidos.
• Falhas de software. Nenhuma recomendação específica, mas deve haver histórias em relação a um tratado.

Proponho usar outra metodologia para gerenciar seu processo, pois, como você diz, é impossível agendar reuniões (o que é absolutamente importante para o scrum!). Ainda não há nada ruim para criar um bom conceito, para que todos saibam o que está acontecendo (provavelmente também usando um protótipo vert) e usando o modelo em cascata. De qualquer maneira, a comunicação é a maior parte do trabalho.

Gostaria de encorajá-lo a usar o controle de origem, se ainda não o é. Isso permite que você veja o que foi verificado por cada desenvolvedor e permite regredir onde um bug foi introduzido.

Eu configuraria algum tipo de suíte de testes. Pode ser um desenvolvimento orientado a testes onde você escreve testes para cada função que está comprometendo ou pode ser uma maneira automatizada de executar seus aplicativos e fazer com que eles produzam os resultados em um arquivo que pode ser comparado ao desejado resultado. Se isso for executado após cada confirmação ou executado pelo menos uma vez por noite, você encontrará as regressões rapidamente.

A última coisa que eu faria é implementar 2 políticas: 1) todas as compilações devem ter avisos definidos como erros e todos os erros ativados 2) Todo o código deve passar pelo analisador estático sem produzir nenhum erro ou aviso antes de ser confirmado. Eu até faria disso uma ação de pré-confirmação. Essas duas coisas impedirão que o código fique horrível rapidamente de várias maneiras comuns. (Eles não pegam tudo, mas pegam muito.)

Isso também preparará seus alunos para como será o trabalho no "mundo real" e incutirá alguns hábitos razoavelmente bons neles.