Por que testadores e programadores não se gostam? [fechadas]

Durante minha carreira como programador, vi vários programadores e testadores, e muitos deles não se gostavam. Quero dizer, os programadores pensam que o trabalho de um testador não é um trabalho "real", e os testadores acham que os programadores estão "orgulhosos" demais.

Essa é a decisão certa tomada por mim, por que e o que podemos fazer para evitar esses problemas amáveis?

Eu acho que isso é muito generalizado e simplificado.

Atualmente, sou testador, escrevo quase o mesmo código que escrevi como desenvolvedor (depende da fase de teste) e meu melhor amigo na empresa é desenvolvedor e todos nós nos damos bem.

Você pode dar uma olhada na cultura corporativa e na maneira como as equipes trabalham umas com as outras para encontrar sua resposta. Na minha experiência, se você tiver fluxos de trabalho muito reacionários (por exemplo, os devs "lançam uma compilação por cima do muro para testar" e testam "lança bugs de volta") em vez de trabalharem juntos , apenas a partir de diferentes pontos de foco ou "vetores de ataque", então você ' Vou descobrir que ambos os departamentos em geral, não gostam um do outro.

Onde trabalho, toda equipe de recursos ou equipe de design tem quase tantos testadores quanto desenvolvedores trabalhando juntos para produzir resultados. Essa saída é um código de produção que atende aos requisitos estabelecidos pelo código de teste.

editar

Observe também que acho que o ônus está no testador mais do que no desenvolvedor para apoiar o relacionamento entre os dois.

É muito mais fácil melhorar ou piorar a vida do desenvolvedor, mas o objetivo não é simplesmente "encontrar bugs", mas também encontrar soluções em potencial. Se não posso, não posso e trabalharei com quem receber o bug nesse momento para encontrar uma solução. Mas se for uma solução simples, fornecerei o que acredito ser uma correção em potencial que satisfaria os vários requisitos e o eventual teste de regressão que escreverei.

EU AMO meus testadores - eles me ajudam a solucionar problemas e identificar coisas que eu não consideraria um problema, mas nossos clientes o fariam. E o mais importante para mim, eles me ajudam a garantir que eu não mate alguém com código incorreto.

Por que os problemas aparecem?

• Você está constantemente julgando o trabalho uns dos outros, e algumas pessoas não podem aceitar nenhum tipo de crítica
• Fazer um trabalho ruim desperdiça o tempo do seu oposto
• Vocês dois estão sob pressão, ao mesmo tempo, pela mesma coisa e ninguém quer ser o único a sustentar as coisas

A combinação dos itens acima, juntamente com a natureza das posições, significa que é realmente fácil exaltar suas angústias e frustrações atuais, se você cair nessa armadilha, para de trabalhar em conjunto e começa a trabalhar um contra o outro. Isso é difícil de sair e não é bom para ninguém.

Eu acho que isso acontece porque os programadores criam um programa e eles percebem que os testadores tentam encontrar falhas nele (mesmo que os testadores realmente façam parte da melhoria do produto final). Sempre que alguém encontra falhas em algo em que você se esforça, é provavelmente uma reação natural reagir negativamente a elas.

As maneiras de mitigar isso seriam fazer com que os desenvolvedores e testadores vejam o produto acabado como o resultado de toda a equipe (incluindo testadores e desenvolvedores) e os façam entender que o teste não é uma missão autônoma de detecção de falhas, mas uma parte importante do processo. o processo de desenvolvimento . E se os desenvolvedores não acham que o teste é um trabalho real ou fácil, peça para que escrevam as matrizes de teste, executem centenas de casos de teste, documentem cada etapa e cada resultado.

Conheço programadores e testadores específicos que não gostam um do outro, mas não pelos motivos que você declarou, mas porque eles fazem o trabalho um para o outro.

É a natureza da besta. Alguns dos testadores em particular que conheço que não se importam com programadores em particular porque acham que seu código está propenso a erros por descuido / preguiça / etc. Alguns dos codificadores em particular que conheço que não se importam com testadores específicos consideram que usavam condições de teste ridiculamente inventadas (picking nits) ou solicitavam revisões do código com base no estilo.

Eu acho que manter as personalidades fora disso e focar na tarefa em questão ajuda bastante a reduzir as tensões. Se uma organização é grande o suficiente, o teste duplo-cego é uma ótima idéia.

Um testador que pode expressar claramente problemas e codificadores que implementam soluções claramente são uma ótima equipe.

Nas equipes em que trabalhei de perto com os testadores, nos demos muito bem. Os testadores compreendem as decisões tomadas em várias decisões, sabem como são os horários dos desenvolvedores e um relacionamento é construído entre os dois grupos.

Nas equipes em que o teste é uma entidade amorfa no exterior, esse não foi o caso. Os resultados dos testadores são menos relevantes, porque eles não sabem muito sobre o que está acontecendo, os desenvolvedores começam a temer o fluxo do que consideram detalhes irrelevantes, que estão em partes do programa que não foram tocadas em dois meses, a equipe de teste fica irritada porque nenhum dos bugs arquivados está sendo corrigido (porque o cronograma está estragado e os desenvolvedores estão ocupados se preparando para demos ou adicionando recursos solicitados etc.) e, em geral, os dois grupos se vêem como antagônicos "outros" em oposição aos membros da equipe.

Trabalhe em estreita colaboração e tudo ficará bem. Alguém precisa garantir que as duas equipes estejam coordenadas e na mesma página. Minha melhor experiência, a equipe de teste foi convidada para qualquer reunião de alto nível para a qual a equipe de desenvolvimento foi convidada (todos eles) e todos sabíamos o cronograma, tínhamos uma lista de prioridades unificada e os desenvolvedores e testes tinham o mesmo (up- até o momento). Minha pior experiência (exceto teste): basicamente empacotamos nossas coisas, enviamos para o exterior para serem analisadas e recuperamos tudo um mês depois com coisas marcadas como erradas que nem eram nossas (plug-in de terceiros que conhecia o novo requisitos, mas não as expectativas da equipe de teste).

Nenhum desenvolvedor ou teste terá êxito sem o outro. Se você trabalha como duas metades da mesma máquina e respeita o outro lado tanto quanto respeita os membros mais imediatos da equipe, tudo ficará bem. Comporte-se como duas máquinas separadas e assuma que sua máquina é melhor, as coisas serão terríveis.

Quando programadores e testadores não gostam um do outro, geralmente é porque eles imaginam erroneamente que seus objetivos conflitam.

Descobri que esses problemas são bastante atenuados quando testadores e desenvolvedores estão na mesma equipe, em vez de uma "equipe de teste" e uma "equipe de desenvolvimento". Acho que é por isso que, como testador, prefiro trabalhar com equipes ágeis, em vez de desenvolver em cascata. Há mais comunicação, o retorno é mais rápido e os desenvolvedores apreciam mais o tempo e o talento que são testados quando esse trabalho é mais transparente.

Individualmente, há muito que pode ser feito também. Como testador, acho que sou capaz de reduzir esse atrito fornecendo feedback positivo e encontrando bugs. Ainda tenho que testar um desenvolvedor que não pode me ensinar muito , e acho que os desenvolvedores apreciam um testador que realmente trabalha para entender o código. Os desenvolvedores têm orgulho, como qualquer bom artesão. É importante que eles saibam que ter bugs não os torna menos admiráveis

Os desenvolvedores que achei mais fáceis de trabalhar com qualidade apreciada e demonstraram isso fazendo um esforço para escrever código de alta qualidade antes que o testador o visse, incluindo testes preliminares (principalmente testes de unidade automatizados e testes de fumaça manuais). Esses desenvolvedores também solicitaram que o teste fizesse análises de código para verificar a testabilidade e incluíram testadores no processo o mais rápido possível, incluindo a apresentação de projetos para eles desde o início (o que permite que os testadores comecem a planejar estratégias de teste mais cedo, quando o teste tem uma carga menor). Os desenvolvedores podem ajudar os testadores a encontrar áreas fracas em seu código, informando quais áreas foram desenvolvidas rapidamente ou quais áreas foram difíceis de realizar no teste de unidade. Em geral, tudo o que os desenvolvedores podem fazer para facilitar o trabalho do testador é apreciado e mostra que eles valorizam o tempo do testador e também o seu. Quando os desenvolvedores fazem isso,

Outro problema é que o controle de qualidade geralmente é um reflexo tardio de muitas empresas. Muitas vezes, é informado sobre projetos no último minuto e tem uma escassez de recursos em comparação à equipe de desenvolvimento. Em alguns lugares, o caminho para o desenvolvedor é o suporte técnico, o controle de qualidade e depois o desenvolvedor. Às vezes, há pessoas que desejam ser desenvolvedores ... E quando encontram um defeito, sua atitude é como essa pessoa pode ser uma desenvolvedora e não eu. Eu nunca cometeria esse erro, etc.

No geral, eu adoraria uma equipe de controle de qualidade. Também acho que o teste de unidade deve ser uma parte necessária do desenvolvimento de software, separada do controle de qualidade. Portanto, quando o controle de qualidade encontra bugs, os testes de unidade são alterados para testar isso. Além disso, acho que os desenvolvedores que testam a unidade podem entender melhor o que o controle de qualidade está encontrando.

Além disso, muitas equipes de controle de qualidade precisam fazer as coisas manualmente; nesse caso, é um trabalho MUITO chato. Em alguns lugares, o controle de qualidade grava scripts e usa programas de automação que permitem até GUIs de script (através de algum tipo de reconhecimento de imagem na tela para botões / etc.). Ainda é difícil quando grandes mudanças acontecem a princípio, mas tudo é automatizado e parece mais divertido ...

Alguns desenvolvedores também ignoram o controle de qualidade. Ainda assim, prefiro o controle de qualidade encontrar um defeito do que o cliente ...

Adoramos nossos testadores aqui, mas muitos de nós lembram como era antes de tê-los. É muito melhor fazer com que os testadores encontrem problemas do que com o cliente depois que você for à produção. Não há um desenvolvedor ativo que não tenha criado um bug ou tenha interpretado mal um requisito.

A chave é tratar todos os profissionais com cortesia e respeito, independentemente de fazerem o que você faz ou não. Depois de começar a pensar que seu trabalho é melhor ou mais importante que o deles, você perde.

Com base nesta pergunta: Técnicas ou categorias de teste de software Suspeito que você precise de um ajuste de atitude em relação aos testadores e testes em geral.

Como desenvolvedor, experimentei minha parcela de tensão com os testadores.

Em um trabalho, os testadores raramente testavam a "coisa certa". Eu implementaria um novo recurso para o servidor do nosso produto, e os testadores relatariam um monte de erros sobre a interface do usuário. Como nesse produto a interface do usuário foi configurada sem codificação , a presença (ou não) de problemas em nossa interface de usuário de desenvolvimento não tinha absolutamente nenhum link para saber se os usuários finais teriam uma interface de usuário com problemas semelhantes. Os testadores sabiam disso, mas persistiram no registro de bugs sobre áreas estranhas.

Dito isto, bons testadores valem seu peso em ouro - eu trocaria um desenvolvedor ruim por um bom testador em um instante. Um bom testador é um parceiro no fornecimento de um produto de qualidade.

Também conheci alguns desenvolvedores que tratam os testadores como inimigos - como se eles estivessem apresentando as falhas. É importante que os desenvolvedores percebam que os testadores nunca apresentam a falha - eles apenas a descobrem.

Como evitar esses problemas? Que tal sermos legais um com o outro? Um precisa do outro para obter um aplicativo de software de qualidade. Por que não respeitar o que cada lado precisa fazer para conseguir isso? Conheça o que cada lado faz e você poderá realmente apreciar o trabalho envolvido.

A teimosia dos dois lados sobre a interpretação correta de um requisito seria onde eu tendia a ver o conflito entre desenvolvedores e testadores em geral. Embora possa haver uma aparência de esnobismo ou arrogância, é só que cada lado gruda nas armas e quer estar certo.

Uma boa maneira de evitar esse problema é ter três partes, o desenvolvedor, o testador e algum mediador, um analista de negócios ou gerente de projeto, trabalhando em como os vários casos de fronteira devem ser tratados. Algo a considerar é que tipo de egos pode surgir quando há uma discordância entre desenvolvedores e testadores.

O mau pressentimento é geralmente o resultado de uma comunicação ruim, que geralmente é o resultado dos programadores e testadores terem diferentes perspectivas do código. O programador conhece os bits nos quais está trabalhando intimamente, mas pode não saber como eles se encaixam no sistema geral (além do que a especificação diz a ele). Os testadores veem o quadro geral, mas não conhecem o código em detalhes. Os grupos podem usar terminologia e procedimentos diferentes para as mesmas coisas.

Isso pode levar a que os defeitos sejam arquivados contra o componente errado (porque o componente está respondendo a uma falha upstream) ou os desenvolvedores fecham defeitos legítimos porque não conseguem reproduzir o problema em seu ambiente (porque realmente não entendem como reproduzir o problema corretamente). Se isso acontecer muito, pode prejudicar as relações entre os grupos.

Depois, há a alegria de obter um lote de defeitos na 11ª hora; os prazos estão chegando, a pressão está chegando do seu gerente imediato na cadeia e você recebe um novo lote de defeitos em um problema que você sabe que já corrigiu e que realmente não quer ter tempo para ir através do processo para provar isso.

Uma maneira realmente boa de irritar sua equipe de controle de qualidade é encerrar sumariamente várias centenas de defeitos legítimos, mas de baixa prioridade (principalmente arquivados contra UIs feias ou inconsistentes que, de outra forma, funcionavam) com o raciocínio de que seu backlog de defeitos de maior prioridade é tão grande que " nós nunca chegaremos a isso. " Você passa do vermelho para o verde na planilha do gerente de programa e recebe um atendente do gerenciamento superior, enquanto a equipe de controle de qualidade é afetada por suas métricas por registrar vários defeitos falsos.

Bad juju.

Isso geralmente surge de três fatores -

• Questões como essas apontam para a existência de um "folclore" na indústria em que desenvolvedores e testadores não gostam um do outro. As pessoas tentam encontrar aspectos que reforçam isso, mesmo quando esse sentimento pode não existir em sua equipe.
• Gerentes de projeto incompetentes que medem o progresso por métricas como o número de bugs registrados.
• Uma equipe disfuncional (e a falta de líderes que se importam o suficiente para consertá-la).

Eu gosto de testadores, mas em dois casos eu encontrei conflito.

1. Quando a gerência joga os testadores e os desenvolvedores.

2. Quando são constantemente enviados problemas sem detalhes, ou seja, "Tela x não funciona".

Eu acho que se esse é realmente o caso, é um sinal de imaturidade. Às vezes você pode falar sobre isso como uma piada. Mas se você (desenvolvedores e testadores trabalhando no mesmo projeto) não se sentir como uma equipe, o resultado seria um desastre.

O teste é uma parte muito importante do ciclo de vida de desenvolvimento de software (seja ágil ou não). Portanto, você não deve pensar nos testadores como pessoas que vivem para incomodá-lo com bugs, mas como um companheiro de equipe que ajuda a fornecer software de qualidade.