Lidar com um desenvolvedor ignorando continuamente casos extremos em seu trabalho

Acho que tenho um problema interessante, bastante comum, com um dos desenvolvedores da minha equipe. O cara é um ótimo desenvolvedor, trabalha rápido e produtivo, produz código de boa qualidade e tudo. Bom engenheiro. Mas há um problema com ele - muitas vezes ele falha em resolver casos extremos em seu código.

Conversamos com ele sobre isso muitas vezes e ele está tentando, mas acho que ele simplesmente não pensa assim. Portanto, o que acaba acontecendo é que o controle de qualidade encontra muitos problemas com seu código e o devolve para o desenvolvimento repetidamente, resultando em prazos perdidos e todos na equipe insatisfeitos.

Não sei o que fazer com ele e como ajudá-lo a superar esse problema. Talvez alguém com mais experiência possa aconselhar?

Exija que ele escreva testes de unidade automatizados para seu código. Escrever testes de unidade obriga a pensar nos casos extremos.

Alguns detalhes:

1. Para garantir que ele não se sinta destacado, isso deve ser instituído para toda a equipe. Exija que todos escrevam testes de unidade automatizados para o novo código ou código que eles modificam.
2. Exija que os nomes dos testes de unidade sejam descritivos quanto ao caso em que estão testando.
3. Cubra os testes de unidade automatizados na revisão de código em um nível alto. Peça aos revisores que procurem casos de teste perdidos (ou seja, aqueles casos extremos dos quais ele sempre perde). Após uma certa quantidade de feedback de sua equipe sobre casos extremos perdidos, ele provavelmente aprenderá a considerá-los antes da revisão.
4. Aplique esta regra a toda a equipe: se o controle de qualidade encontrar um bug, o desenvolvedor responsável deve o teste automatizado que confirma a falha e prova que a corrigiu. (antes de fazer qualquer outro trabalho)

Dê a ele uma lista de verificação, por exemplo

• entradas nulas
• entradas no extremo extremo grande da faixa
• entradas no extremo pequeno final da faixa
• combinações
• entradas que violam os invariantes assumidos (por exemplo, se x = y)

O pessoal do controle de qualidade pode ajudar a elaborar a lista de verificação

Dê a lista de verificação a todos os desenvolvedores, não apenas a este.

Bom engenheiro.

OK.

Mas há um problema com ele - muitas vezes ele falha em resolver casos extremos em seu código.

É uma qualidade que os bons engenheiros não compartilham.

Observar casos extremos é uma característica presente ou não nas pessoas. Não tem nada a ver com ser engenheiro ou programador. O desenvolvimento dessa característica é influenciado pelo contexto cultural, ambiente de vida, eventos da infância e experiências de vida. Então, a atitude é simplesmente aplicada a qualquer trabalho que um indivíduo esteja realizando.

O que você precisa é descobrir se sua pessoa é daquele tipo que ainda não desenvolveu esse sentido (talvez ainda). Também é muito provável que ele simplesmente não se importe por algum motivo ou outro. Você precisa analisar toda a situação, se ele está feliz em seu trabalho. Se não, então talvez você deva fazer algo para ajudá-lo primeiro.

Se ele está bem com o trabalho, mas ainda não experimentou o perigo de casos extremos, você pode começar a educá-lo. Se ele levar a sério, pode mudar de atitude com o tempo. Embora eu seja cético em relação a isso, você ainda pode tentar.

Se, no entanto, ele for o tipo de pessoa que não é boa em casos extremos, talvez você não tenha mais nada a não ser removê-lo da equipe. Essa característica é essencial para a programação prática. Infelizmente, sem ele, mesmo uma grande pessoa não produziria um bom trabalho.

Você poderia fazer revisões de código ou de design no início do processo?

Ensine-o a programar o teste primeiro. Emparelhe com ele. Você escreverá os casos de teste e ele escreverá o código para passar nos testes.

O envolvimento do controle de qualidade com antecedência suficiente no desenvolvimento de recursos pode ajudá-lo a fornecer uma lista de casos extremos desde o início a serem abordados? Embora alguns possam ver isso como não esperando que o desenvolvedor cubra tudo, isso pode ser uma maneira de contornar isso, se ele tende a perder os casos-limite que um testador pode capturar inicialmente.

A outra idéia que eu teria aqui é como ele vê esse problema. Ele está realmente irritado e se irrita com esse padrão ou apenas vê isso como normal e não é algo para se preocupar em resolver? É verdade que isso exige muita confiança e que ele seja aberto em sua perspectiva, mas acho que há um certo grau de empatia aqui que pode ajudar se você puder ver as coisas da perspectiva dele.

Há um número infinito de casos extremos, cobrindo todos eles é inviável. E se alguém fizer #define TRUE FALSE? Ele adiciona casos extremos, você também os verifica?

Além disso, eu não consideraria a prova de idiotas todas as funções de uma classe privada ou função interna.

A abordagem que escolhi para o código que precisa ser muito sólido e estável é:

if(conditions_met)
{
DoStuff();
}
else
{
CrashAppAndDumpMemory();
}

Dessa forma, você obtém sólidos despejos de aplicativos no controle de qualidade e, quando chega a um lançamento, o aplicativo é sólido e seguro.

Contornar os erros é ruim. Ok, você pode salvar uma função se o identificador do arquivo for nulo e retornar nulo, mas na maioria dos casos, há um erro de design em algum lugar, e a falha do aplicativo é a melhor maneira de forçá-lo a encontrar a causa. A maioria dos casos extremos apenas oculta o erro, ocultando um problema, digamos - o botão parou de funcionar. O Crash informa que algumas suposições sobre o produto estão erradas e você deve revisar a lógica que causou a falha.

Se é um caso extremo, ele precisa ser considerado? Se os casos extremos são importantes, os casos extremos precisam ser inseridos nos requisitos / recurso / história do usuário.

Se os casos de aresta tiverem sido considerados como parte de uma peça de trabalho e for necessário que os dispositivos sejam colocados no local, eles deverão fazer parte do item de trabalho e, por definição, o item de trabalho não estará completo até que o mecanismo para lidar com o caso de aresta seja no lugar.

Isso fornece a você, como líder da equipe, algo para desmarcá-lo após a conclusão do trabalho durante a discussão pós-trabalho, e ao desenvolvedor algo para desestimular quando ele concluir o trabalho.

É por isso que existe um controle de qualidade. Os programadores têm a responsabilidade de realizar o trabalho em tempo hábil. Passar o tempo todo procurando casos extremos é muito ineficiente. Se você tiver um ciclo iterativo razoavelmente rápido, isso não deverá ser um problema. Os casos de borda são quase infinitos. Se houvesse um problema com os casos "principais", eu ficaria um pouco preocupado. Assim como os desenvolvedores são especialistas em desenvolvimento, um testador deve ser um especialista em testes. Quando um testador encontra um problema, ele o envia de volta ao desenvolvimento. O desenvolvedor corrige o problema. Problema resolvido. O tempo para um desenvolvedor rastrear todos os casos extremos é muito mais longo do que o ciclo de teste iterativo deve levar. Observe também que, quando estou falando de testes, não me refiro a testes de unidade de caixa branca, mas estritamente a testes de caixa preta.

Esse é um dos casos em que acredito que o desenvolvimento orientado a testes vem para resgatar, porque ajuda a pensar em termos de casos extremos e qualquer coisa que possa quebrar o código.