Como convencer meus colegas de equipe de que não devemos ignorar os avisos do compilador?

Trabalho em um grande projeto (mais como uma combinação emaranhada de dezenas de mini-projetos que não podem ser facilmente separados devido ao mau gerenciamento de dependências, mas essa é uma discussão diferente) em Java usando o eclipse. Já desativamos vários avisos das configurações do compilador e o projeto ainda possui mais de 10.000 avisos.

Sou um grande defensor de tentar abordar todos os avisos, corrigi-los, se possível, e para aqueles que são examinados e considerados seguros, suprima-os. (O mesmo vale para a minha obsessão religiosa em marcar todos os métodos implementados / substituídos como @Override). Meu maior argumento é que geralmente os avisos ajudam a encontrar possíveis erros durante o tempo de compilação. Talvez em 99 das 100 vezes, os avisos sejam insignificantes, mas acho que a cabeça coçando que salva pela primeira vez que evita um bug grave vale a pena. (Meu outro motivo é meu TOC aparente com limpeza de código).

No entanto, muitos dos meus colegas de equipe não parecem se importar. Ocasionalmente, conserto avisos quando tropeço neles (mas você sabe que é complicado quando você toca no código escrito por um colega de trabalho). Agora, com literalmente mais avisos do que classes, as vantagens dos avisos são muito minimizadas, porque quando os avisos são tão comuns, ninguém se preocupa em examiná-los.

Como convencer meus colegas de equipe (ou os poderes que existem) de que os avisos precisam ser tratados (ou suprimidos quando totalmente investigados)? Ou devo me convencer de que sou louco?

obrigado

(PS: esqueci de mencionar o que finalmente me levou a postar esta pergunta é que, infelizmente, notei que estou corrigindo os avisos mais devagar do que os produzidos)

Você pode fazer duas coisas.

1. Saliente que os avisos existem por um motivo. Os escritores de compiladores não os colocam porque são mesquinhos. As pessoas do nosso setor geralmente são úteis. Muitos avisos são úteis.

2. Reúna um histórico de falhas espetaculares decorrentes de avisos ignorados. Uma pesquisa na web por "Preste atenção aos avisos do compilador" retorna algumas anedotas.

Sua obsessão por @Overridenão é uma "obsessão". Isso é uma coisa boa. Já digitou incorretamente o nome de um método?

Leitura relevante aqui . C ++, mas ainda relevante. Eu particularmente gosto deste exemplo (o comentário do código é meu):

int searchArray(int to_search[], int len, int to_find)
{
    int i;
    for( i = 0; i < len; ++i )
    {       
        if ( to_search[i] == to_find )
        {
            return i;
        }
    }
    // should be returning designated 'not found' value (0, -1, etc)
}

Muitas vezes, um aviso significa a diferença entre o aplicativo travar com um erro que realmente o ajuda a rastrear uma falha de design e corrigi-la (como a digitação segura ) ou o aplicativo que faz suposições e, na verdade, se comporta de maneira incorreta. ou de maneira incorreta (o que seria o caso da conversão de texto insegura ). Da mesma forma, eles também apontam códigos cruft ou inoperantes que podem ser removidos (blocos de código inacessíveis, variáveis ​​não utilizadas), que podem ser considerados otimização de código ou casos não contabilizados que aparecerão nos testes, como o exemplo acima para C ++. Observe que este exemplo resulta em um erro de tempo de compilação em Java.

Portanto, a fixação de avisos tem (pelo menos) várias vantagens para o gerenciamento:

1. Menos chance do código se comportar de maneira inadequada com os dados inseridos pelo usuário que, para os superiores preocupados com a imagem da empresa e com a forma como ele lida com os dados de seus clientes, devem ser um grande negócio (tm). Falha na prevenção de um usuário fazer algo bobo é melhor do que não travar e deixá-lo fazer isso.
2. Se eles quiserem reorganizar o pessoal, as pessoas podem entrar em uma base de código livre de aviso (e não surtar ou reclamar tanto ..). Talvez isso reduza a quantidade de resmungos ou opiniões sobre a manutenção ou a qualidade da contribuição da Equipe X ao Projeto Y.
3. A otimização do código removendo os avisos do compilador, embora não ofereça melhorias significativas no tempo de execução, melhorará várias pontuações no que diz respeito aos testes:
   • Qualquer pontuação de cobertura de código provavelmente aumentará.
   • O limite de teste e os casos de teste inválidos provavelmente serão bem-sucedidos com mais frequência (devido à conversão de texto segura acima mencionada , entre outras coisas).
   • Quando um caso de teste falha, você não precisa pensar se é devido a um dos avisos do compilador nesse arquivo de origem.
   • É fácil argumentar que zero avisos do compilador são melhores que milhares. Nenhum aviso ou erro fala sobre a qualidade do código; portanto, você pode argumentar que a qualidade do código melhora os menos avisos existentes.
4. Se você não possui avisos do compilador e um ou mais são introduzidos, é muito mais fácil saber quem os causou na base de código. Se você tem uma política de "sem avisos", isso os ajudaria a identificar pessoas que não estão fazendo seu trabalho corretamente, talvez? Escrever código não é apenas fazer com que algo funcione, é fazer com que funcione bem .

Observe que ainda sou apenas um desenvolvedor júnior que sabe pouco sobre gerenciamento de projetos, por isso, se eu disse algo errado, corrija meu pensamento e me dê a chance de editar antes que você me diminua da existência :)

Eu trabalhei em um projeto com características semelhantes no passado. Este em particular foi originalmente escrito em Java 1.4. Depois que o Java 5 com genéricos é lançado, pode-se imaginar o número de avisos lançados pelo compilador para cada uso da API Collections.

Levaria algum tempo para se livrar de todos os avisos, começando a usar genéricos. Esse é um fator que deve ser levado em consideração, mas quando você precisa convencer alguém (especialmente seu gerente) de que ele precisa ser corrigido, você precisará de dados concretos, como

o tempo gasto em bugs no código legado ou não compatível com o padrão (o padrão é o padrão de codificação do seu projeto) que poderia ter sido evitado.

Você pode continuar apresentando um projeto de lei que demonstre como está perdendo tempo e dinheiro ignorando avisos "certos", e alguém entenderá. A parte principal é que nem todos os avisos valem a pena ser observados, pelo menos não imediatamente; em palavras mais simples, você precisará estabelecer a prioridade dos avisos que precisam ser endereçados imediatamente. Para começar, considere os pertinentes aos bugs que você está vendo no seu projeto.

Você também pode fazer anotações no rastreador de bugs, ao corrigir bugs, de que o bug mencionado poderia ter sido evitado por não ignorar um aviso (ou talvez executando PMD ou FindBugs se você tiver um IC ou um sistema de compilação). Desde que haja um número suficiente de bugs que possam ser corrigidos, atendendo aos avisos do compilador, seu argumento sobre a observação de avisos do compilador será válido. Caso contrário, é uma decisão de negócios e, geralmente, não vale o tempo gasto para combater esta batalha.

Se você tiver sucesso e sua equipe decidir observar os avisos, faça uma abordagem passo a passo. Ninguém pode e receberá 10000 avisos de uma só vez. Assim, você pode selecionar os mais importantes (aqueles que são bugs com alta probabilidade) e desativar os menos significativos. Se eles estiverem corrigidos, aumente o nível de aviso novamente. Além disso, você pode começar com o FindBugs, que avisa sobre o código que quase sempre é um bug.

Concordo totalmente com você, é uma prática recomendada limpar o máximo possível os avisos de compilação. Você mencionou que sua equipe está usando o Eclipse como ferramenta de desenvolvimento. O Eclipse é uma ferramenta muito boa para ajudá-lo a limpar o código e tornar a consistência do estilo do código.

1. defina 'Salvar ação' para cada projeto Java, como formatar código, variáveis ​​locais não utilizadas, organizar as importações (acho que ninguém tem objeções a esse tipo de limpeza).
2. defina opções de compilação específicas do projeto para cada projeto. Por exemplo, nível de compilação (se seu código precisar ser compatível com 1.4 para limpar os avisos relacionados a genéricos), a atribuição não terá efeito (por exemplo, 'x = x') e assim por diante. Você e seu colega de equipe podem fazer um acordo para esses itens e o Eclipse os reportará como 'Erro' em sua fase de desenvolvimento depois que você concordar com o erro de compilação.

O Eclipse criará alguns arquivos de propriedades para essas preferências na pasta .settings. Você pode copiá-los para outros projetos Java e fazer check-in no SCM como parte do código-fonte.

Você pode verificar o código do Eclipse para ver como os desenvolvedores do Eclipse o fazem.

Você tem duas maneiras de se livrar de todos os avisos (e eu concordo que isso pode ocultar um bug sutil):

1. Convença a equipe inteira de que essa é a melhor coisa a fazer e peça para que conserte.
2. Convença seu chefe de que isso é a melhor coisa a fazer e torne-o obrigatório. Então eles precisam consertar isso.

Eu acredito que 1 não é mais possível no seu caso. Além disso, isso provavelmente levará tanto tempo devido ao número de avisos que serão exibidos no resultado da produtividade, para que o gerenciamento precise saber de qualquer maneira.

Então, minha sugestão é: aceite com o chefe, convença-o de que é uma bomba e faça política oficial.

Eu apenas diria a eles que a maioria destes são avisos insignificantes e é essencial removê-los da lista. Para que não perca o verdadeiro aviso significativo na multidão, como acontece!

Você precisará de muita paciência ao tentar convencê-los, remover os avisos ao fazer a programação em pares ajudará outras pessoas a adquirir o hábito. Sugira-lhes que leiam o Item 24 do Java Efetivo: Eliminar Avisos Não Verificados (para coleta genérica). E provavelmente ignore muitos casos em que as pessoas não seguem seus conselhos;)

Uma abordagem eficaz aqui seria configurar um servidor de Integração Contínua que construa automaticamente o projeto e execute os testes sempre que alguém fizer o check-in do código. Se você ainda não está usando isso, deve estar, e não é muito difícil convencer os outros dos benefícios de fazê-lo.

1. Convença os líderes de gerenciamento / equipe dos benefícios de fazer isso (impedindo que implantações ruins sejam implantadas, localizando bugs mais cedo, especialmente aqueles que afetam acidentalmente outras partes do software, mantém testes de regressão, testes iniciais e frequentes, etc.)

2. Instale o servidor de CI com todos os testes aprovados (se você não tiver testes, escreva um rápido que seja aprovado, para que todos vejam que é verde).

3. Configure emails ou outras notificações sobre o status de cada build. É importante incluir aqui quem fez o check-in no código, qual foi a alteração (ou um link para a confirmação) e o status + saída da compilação. Este é um passo importante, pois causa visibilidade em toda a equipe, tanto para sucessos quanto para falhas.

4. Atualize o servidor de IC para fazer com que os testes falhem se houver algum aviso. Isso será visto pelos líderes da gerência e da equipe como um aumento sistemático da disciplina da equipe, e ninguém quer ser responsável por todos os emails de falha enviados.

5. (opcional) fique agradável e nerd com isso, adicionando painéis visíveis, lâmpadas de lava, luzes piscantes etc. para indicar o status da construção e quem a quebrou / a corrigiu.