<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by QA School on Medium]]></title>
        <description><![CDATA[Stories by QA School on Medium]]></description>
        <link>https://medium.com/@qaschool?source=rss-31bdb5355af0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*m8HjUA29nXyZbyiRMDEljA.png</url>
            <title>Stories by QA School on Medium</title>
            <link>https://medium.com/@qaschool?source=rss-31bdb5355af0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 15:51:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@qaschool/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[DevTestOps/QAOps]]></title>
            <link>https://medium.com/@qaschool/devtestops-qaops-53d1ce6d2d1f?source=rss-31bdb5355af0------2</link>
            <guid isPermaLink="false">https://medium.com/p/53d1ce6d2d1f</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[operations]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[QA School]]></dc:creator>
            <pubDate>Sun, 13 Sep 2020 14:57:33 GMT</pubDate>
            <atom:updated>2020-09-13T14:58:42.491Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>O objetivo é aumentar a visibilidade dos testes</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*dHtUywf2zXstJycubgLgEA.jpeg" /></figure><h4>Melhore a qualidade do código e a adoção da automação de teste</h4><p>Nenhum commit fica sem teste, devemos nos concentrar em tarefas repetitivas e em estratégia de automação baseada em risco (não automatize tarefas que não terão que ser repetidas).</p><h4>Formatos Multi-Teste</h4><p>Todos os tipos de teste, como unidade, integração, API, UI, banco de dados, teste exploratório, devem ser incorporados durante o ciclo de entrega e as tarefas de teste repetitivas devem ser automatizadas.</p><h4>Métricas e Painéis</h4><p>Mantenha o controle dos principais indicadores de qualidade (por exemplo, defeitos na produção, análise de risco, conclusões de requisitos, entre outros). Melhore continuamente o processo de qualidade.</p><h4>Testes de Desempenho e de Carga</h4><p>Incentive as métricas de teste de desempenho e carga para evitar qualquer travamento ou interrupção nas aplicações. Lembre-se do comportamento do sistema em termos de atributos como velocidade, tempo de resposta, taxa de transferência, uso de recursos, estabilidade, problemas de largura de banda e capacidade do sistema existente.</p><h4>Aprendizado Contínuo</h4><p>Aprender é um núcleo a ser explorado. Os testes exploratórios permitem a descoberta de informações surpreendentes, devemos continuar aprendendo para possibilitar uma melhor qualidade.</p><h4>Monitoramento de possível risco na produção</h4><p>Testar e monitorar em produção é uma ótima maneira de aprender como seu sistema está realmente funcionando com usuários reais, solicitações reais e dados reais. As informações que coletamos podem ser expandidas para fornecer uma visão mais completa da aplicação e evitar riscos.</p><blockquote>A qualidade deve estar no produto/serviço e o teste deve ser deslocado para a esquerda/direita.</blockquote><p>Este artigo foi traduzido da <a href="https://kutt.it/biQQ8W">publicação</a> de <a href="https://www.linkedin.com/in/enrique-a-decoss-9014a338/">Enrique A Decoss</a> no LinkedIn.</p><p>Acompanhe as novidades da QA School também lá no Linkedin: <a href="https://www.linkedin.com/company/qaschoolbr/">https://www.linkedin.com/company/qaschoolbr</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53d1ce6d2d1f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Processo de Teste Ágil]]></title>
            <link>https://medium.com/@qaschool/processo-de-teste-%C3%A1gil-b51c6c139a87?source=rss-31bdb5355af0------2</link>
            <guid isPermaLink="false">https://medium.com/p/b51c6c139a87</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[process]]></category>
            <dc:creator><![CDATA[QA School]]></dc:creator>
            <pubDate>Fri, 11 Sep 2020 18:13:20 GMT</pubDate>
            <atom:updated>2020-09-11T18:13:20.840Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1GzOwXP5C27zAOET4XunCQ.png" /><figcaption>Fonte da Imagem: <a href="https://blog.aevo.com.br/">https://blog.aevo.com.br</a></figcaption></figure><p>O Processo de Teste Ágil possui quatro frentes básicas, com as quais o produto pode ser entregue de forma ágil e com qualidade. Entenda, logo abaixo, cada uma das fases do processo.</p><h4>1 — Sprint Zero</h4><p>Este é o início da fase de teste. Aqui, todos os requisitos estruturais e de configuração dos testes são atendidos. Isso inclui uma série de etapas desde a implementação das ferramentas e recursos materiais necessários para organizar o número necessário de pessoas. Uma análise de outros objetivos envolvidos na iteração 0 (sprint zero) são os seguintes:</p><ul><li>Realizar uma avaliação crítica dos benefícios, custos e riscos envolvidos nas opções alternativas;</li><li>Identificação preliminar de um conjunto de condições que o produto deve atender;</li><li>Preparando o escopo do projeto;</li><li>Fazendo um procedimento iterativo de 5 pontos que ajuda a gerar soluções candidatas. Essa solução facilita a atualização por meio da repetição dessas etapas e, por fim, resulta em um projeto de arquitetura que se adapta a aplicações diversificadas;</li><li>Identificação de risco abrangente;</li><li>Configuração de servidores;</li><li>Provisionamento de backlogs de produtos.</li></ul><h4>2 — Iterações de construção</h4><p>Chamada de coração de todo o Processo de Teste Ágil, a iteração de construção é a fase em que o teste máximo ocorre. O objetivo desta fase é preparar o produto para os testes de pré-produção.</p><p>Para isso, um conjunto de iterações é executado, e cada iteração hospeda uma mistura de recursos do Scrum, XP, Agile Modeling e Agile Data.</p><p>Vários requisitos relacionados ao projeto são reduzidos em uma base prioritária e soluções são desenvolvidas para abordá-los.</p><p>O estágio de iteração de construção compreende dois tipos diferentes de processos de teste, a saber, Confirmatório e Investigativo. O primeiro (Teste Confirmatório) é realizado para comprovar se o produto está em conformidade com os requisitos apresentados por diferentes partes interessadas. Por outro lado, o último (Teste Investigativo) é conduzido para resolver as lacunas que surgem durante o teste de confirmação.</p><h4>3 — Transição</h4><p>Esta fase é a etapa final antes da produção. O objetivo aqui é ajudar o produto a passar para a fase de produção da forma mais perfeita possível. Algumas etapas envolvidas na fase de transição incluem:</p><ul><li>o treinamento do pessoal envolvido nas operações e suporte;</li><li>finalização do lançamento do produto;</li><li>colocação de backups adequados e necessários; e</li><li>preenchimento abrangente da documentação do usuário.</li></ul><p>Nesse estágio, os testadores devem realizar testes exaustivos, incluindo aceitação e teste completo do sistema. Eles também podem ajustar o produto ao descobrir qualquer obstáculo significativo. Para uma melhor proposta neste estágio, o teste deve ser extremamente meticuloso na fase de iteração de construção.</p><h4>4 — Produção</h4><p>Por fim, o produto entra na fase de produção. Aqui, o objetivo é garantir que o produto seja útil para o usuário final, uma vez que ele tenha acesso a ele. O processo de teste no ambiente de produção difere de uma empresa para outra. As necessidades e o tipo de software determinarão a função do teste ágil durante a produção.</p><p>O objetivo é manter as coisas funcionando sem problemas e ajudar os usuários a conseguirem o melhor do produto. Os desenvolvedores podem executar testes direcionados e usar uma lista de sanity checklist (verificação de integridade) diária para garantir a estabilidade do aplicativo.</p><p>Este artigo foi extraído parcialmente, traduzido e adaptado do blog da Mubisoft (<a href="https://mobisoftinfotech.com/resources/blog/agile-development-testing/">https://mobisoftinfotech.com/resources/blog/agile-development-testing</a>).</p><p>Acompanhe as novidades da QA School também lá no Linkedin: <a href="https://www.linkedin.com/company/qaschoolbr/">https://www.linkedin.com/company/qaschoolbr</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b51c6c139a87" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conheça os princípios F.I.R.S.T aplicados em testes de unidade]]></title>
            <link>https://medium.com/@qaschool/conhe%C3%A7a-os-princ%C3%ADpios-f-i-r-s-t-aplicados-em-testes-de-unidade-999c9d2a00d?source=rss-31bdb5355af0------2</link>
            <guid isPermaLink="false">https://medium.com/p/999c9d2a00d</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[videos]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[QA School]]></dc:creator>
            <pubDate>Mon, 07 Sep 2020 05:10:58 GMT</pubDate>
            <atom:updated>2020-09-07T05:10:58.316Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*UVUAMzTG3Oh_Cq8vv5o0vg.png" /></figure><p>Os testes de unidade precisam satisfazer o acrônimo F.I.R.S.T, a saber:</p><h3>Fast</h3><blockquote>Rápidos</blockquote><p>A fim de obter um resultado mais rápido sobre possíveis bugs provenientes de testes no código, os desenvolvedores/QAs devem realizar testes unitários frequentemente.</p><p>Devido a essa necessidade frequente e imediata é que a execução precisa ser rápida, em milissegundos. Claro que nem sempre é possível, mas dividir uma suíte de testes em chunks (pedaços) menores pode ser uma solução.</p><h3>Independent</h3><blockquote>Independentes</blockquote><p>Em nenhum momento crie dependência entre os testes unitários. Isto é, não permita que um determinado <strong>Teste B</strong> dependa do <strong>Teste A </strong>ou vice-versa.</p><p>Lembre-se: a ordem de execução dos testes de unidade é irrelevante. O que possibilita, inclusive, execuções paralelas.</p><ul><li>Use o DRY (Don’t Repeat Yourself) para eliminar dependência entre testes.</li></ul><h3>Repeatable</h3><blockquote>Determinísticos</blockquote><p>Independentemente do ambiente e da quantidade de vezes executadas, os testes unitários devem sempre ter o mesmo resultado. Uma vez que os testes ora passam e ora falham, estes são chamados de Flaky (alarme falso).</p><p>Segundo um estudo do Google (<a href="https://testing.googleblog.com/2016/05/flaky-tests-at-google-and-how-we.html">Flaky Tests at Google and How We Mitigate Them</a>) [2016], aproximadamente 16% dos testes são passíveis de Flaky Tests.</p><h3>Self-Validating</h3><blockquote>Auto-verificáveis/explicativos</blockquote><p>Uma vez finalizada a execução dos testes, o resultado deve binário, ou melhor, auto-explicativo (passou/falhou). Desta forma, o resultado pode ser ligeiramente verificado e interpretado.</p><p>Além disso, um relatório contendo evidências (screenshots, se possível) é uma ferramenta que agiliza a verificação de possíveis falhas nos testes executados.</p><h3>Timely</h3><blockquote>Previamente escritos</blockquote><p>Uma boa prática é escrever os testes antes deles serem executados no código. Obviamente, no início eles irão falhar. No entanto, ao decorrer da implementação do código de produção, os testes começão a passar (caso realmente esteja de acordo com o esperado).</p><p><strong><em>Recurso Adicional:</em></strong></p><p>Vídeo: <a href="https://pt-br.eventials.com/Globalcode/tdc-floripa-2019-stadium-sexta-6/">Construa testes efetivos através do princípio F.I.R.S.T</a> [Elder Moraes]</p><p>Acompanhe as novidades da QA School também lá no Linkedin: <a href="https://www.linkedin.com/company/qaschoolbr/">https://www.linkedin.com/company/qaschoolbr</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=999c9d2a00d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quanto tempo gastar com testes?]]></title>
            <link>https://medium.com/@qaschool/quanto-tempo-gastar-com-testes-71abc4f768a2?source=rss-31bdb5355af0------2</link>
            <guid isPermaLink="false">https://medium.com/p/71abc4f768a2</guid>
            <category><![CDATA[qa-testing]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[automação]]></category>
            <category><![CDATA[teste]]></category>
            <category><![CDATA[projetos]]></category>
            <dc:creator><![CDATA[QA School]]></dc:creator>
            <pubDate>Sat, 05 Sep 2020 14:46:42 GMT</pubDate>
            <atom:updated>2020-09-05T14:46:42.016Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Fonte: https://kidsmartapp.co.uk" src="https://cdn-images-1.medium.com/max/626/1*pj0ypl_R3KdL_9sUEZ9TLQ.jpeg" /><figcaption>Fonte da Imagem: <a href="https://kidsmartapp.co.uk/">https://kidsmartapp.co.uk</a></figcaption></figure><p>Ao planejar um projeto, quanto tempo deve ser reservado para os testes? Não seria suficiente calcular uma porcentagem em relação ao tempo estimado para desenvolvimento? É preciso mesmo planejar isso?</p><h3>No silver bullets</h3><p>Não existe um método mágico e correto para estimar o tempo gasto com testes, assim como não há uma solução mágica para o problema da estimação de software.</p><p>A verdade é que mesmo <a href="http://pt.stackoverflow.com/a/2005/227">especialista em testes sugerem chutar!</a> A princípio, use um fator mágico <strong>arbitrário</strong> para determinar o tempo reservado para testes. No decorrer do projeto, ajuste a proporção conforme sua produtividade e o nível de qualidade exigido.</p><h3>Valores “mágicos”</h3><p>Brooks, autor do famoso livro <em>The Mythical Man-Month</em>, descreve no capítulo 2 sua “regra” para planejar uma tarefa:</p><ul><li>30% para planejamento</li><li>20% para codificação</li><li>25% para testes de componentes e testes antecipados de sistema</li><li>25% para testes de sistema e de integração geral</li></ul><p>Os valores originais estão em frações, mas adaptei para porcentagem para facilitar o entendimento. <strong>Note que os testes ocupam metade do tempo de desenvolvimento (50%), o equivalente a 2,5 vezes o tempo de codificação.</strong></p><p>Tenho notado em minhas atividades individuais que o tempo de testes varia de 1 a 1,5 vezes o tempo de desenvolvimento, incluindo testes unitários efetivos antes da codificação cobrindo cenários com valores limite e excepcionais. Além disso, é necessário mais 1 a 1,5 vezes o tempo de desenvolvimento para testes de integração após a codificação individual.</p><p>Em resumo, posso dizer que <strong>o tempo total de testes, quando feitos adequadamente, varia entre 2 a 3 vezes o tempo de desenvolvimento</strong>. Minha observação pessoal corresponde às observações de Brooks.</p><h3>Pressa: e se não testarmos?</h3><p>A dura realidade é que nem todos se dão ao luxo de separar tempo suficiente para testar. O termo “luxo” aqui foi usado com um pouco de ironia, porque a verdade é que, em última análise, isso é uma questão cultural da empresa e do indivíduo. Não, não tem tanto a ver com o cliente, porque a qualidade do sistema não é responsabilidade dele.</p><p>É responsabilidade dos profissionais de TI fazer o que for necessário para garantir o sucesso do projeto de software para o bem da própria empresa e do cliente, mesmo que as demais áreas não compreendam isso. Se a qualidade exigida não for financeiramente viável, então o projeto como um todo não está bem formulado ou simplesmente deve ser arquivado.</p><p>Tenho algumas considerações importantes que talvez possam ajudar:</p><ol><li>O tempo investido em testes unitários <strong>antes da codificação</strong> efetivamente diminui o tempo de codificação, já que o desenvolvedor tem que considerar cuidadosamente as entradas e saídas. De outra forma, as pessoas tendem a iniciar a codificação de um módulo do programa sem a noção do todo e precisa constantemente revisar o que já fizeram ao se deparar com novos detalhes e requisitos.</li><li>Criar testes <strong>antes da codificação</strong> pode ajudar muito no entendimento do problema, já que o desenvolvedor precisa entender os requisitos para validar os resultados através de asserções.</li><li>Em projetos “legados”, que não possuem testes unitários ou automatizados, o tempo gasto com correções tende ao infinito, pois a taxa de erros nunca estabiliza. Sem testes, não podemos mensurar corretamente o impacto das alterações e correções. A cada passo para frente, damos dois para trás. Uma correção pontual pode causar efeitos colaterais não esperados em outras funcionalidades.</li><li>Uma premissa falsa que muitos tomam por verdadeira é que se as partes de um sistema forem implementadas corretamente, então não haverá problemas ao juntá-las no final. Isso é sempre um erro. Mesmo grandes desenvolvedores que sempre criam código de qualidade não podem evitar testes de integração, de sistema e de aceitação.</li><li>Quanto mais tarde um erro for descoberto, maior o custo para corrigi-lo. Quanto antes os testes entrarem em ação, mais cedo eles podem contribuir para encontrar esses erros e problemas em potencial. Considere a imagem abaixo, extraída do artigo <a href="http://superwebdeveloper.com/2009/11/25/the-incredible-rate-of-diminishing-returns-of-fixing-software-bugs/"><em>The Incredible Rate of Diminishing Returns of Fixing Software Bugs</em></a>:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/507/1*HNHkPAe9ViVrTXSQa-JiyQ.png" /><figcaption><strong>Um tempo bem gasto com testes permitirá aos desenvolvedores terem um horizonte visível do que é esperado do sistema.</strong></figcaption></figure><h3>Sobre estimação de software</h3><p>Em minha pós-graduação, desenvolvi uma monografia sobre estimação de software. No momento em que escolhi este tema, acreditava que iria encontrar um método mágico para determinar o tempo das atividades de um projeto. Obviamente, logo que comecei a pesquisa percebi que havia acreditado num grande engodo.</p><p>Um dos livros mais interessantes de minha bibliografia foi <a href="http://www.amazon.com/Software-Estimation-Demystifying-Practices-Microsoft/dp/0735605351"><em>Software Estimation: Demystifying the Black Art</em></a> de <a href="http://www.stevemcconnell.com/">Steve McConnell</a>, cujo título já esclarece muito sobre a essência das estimativas: elas são tentativas de prever o futuro. <strong>Estimativas são chutes, simples assim</strong>.</p><p>A consequência disso é que não existe, e nunca existirá, uma regra definitiva para estimação das atividades de desenvolvimento de software. Na verdade, métodos “matemáticos” de estimação (<a href="http://pt.wikipedia.org/wiki/M%C3%A9todo_COCOMO">COCOMO</a>, <a href="http://en.wikipedia.org/wiki/Function_point">Function Point</a>) acabam confundindo seus usuários no sentido de que estes acreditam que o resultado terá <a href="http://www.dicio.com.br/acuracia/">acurácia</a> garantida, afinal há todas aquelas fórmulas matemáticas complicadas. Aliás, é comum confundirmos acurácia (resultado bom) com precisão (nível de detalhe, casas decimais), mas uma estimativa pode ser muito precisa, porém longe da realidade.</p><p>Em decorrência disso, as metodologias ágeis não usam valores absolutos para estimar, como horas e dias, mas <em>story points</em> (pontos de história), que são grandezas relativas que variam de acordo com a equipe, o projeto e maturidade do desenvolvedor.</p><p>Os métodos mais modernos também não buscam precisão, isto é, estimar em muito detalhe (horas, por exemplo), já que frequentemente isso diminui a acurácia. Estimar em dias, semanas ou, em alguns casos, meses pode parecer “bruto” demais, porém os resultados são mais realistas. Não concorda? Então pense: quão confiável é uma estimativa de 370 dias e 4 horas? Sinceramente, alguém pode prever tudo o que ocorrerá em praticamente um ano?</p><p>Então, cuidado com soluções mágicas que podem tentar lhe vender. Embora algumas técnicas de estimação <em>pareçam</em> melhores, na verdade ninguém pode afirmar <em>absolutamente</em> que determinado método é melhor. Fazer isto seria o mesmo que afirmar que você tem um método para jogar na loteria <em>melhor</em> que outras pessoas, sendo o resultado simplesmente aleatório.</p><p>Leia algumas conclusões adicionais sobre estimação de software no artigo <a href="http://luizricardo.org/2012/09/reflexoes-sobre-a-natureza-do-software-e-das-estimativas-de-software/">Reflexões sobre a natureza do software e das estimativas de software</a>.</p><p><strong>Mas isso significa que devemos sempre “chutar” durante o planejamento? Claro que não! Podemos chutar <em>com estilo</em>.</strong></p><h3>Estimação por analogia</h3><p>Estimar é prever o futuro. Porém se as atividades de desenvolvimento de um novo projeto são análogas a experiências anteriores, os envolvidos podem ter uma boa ideia do esforço necessário para executá-las.</p><p>Isso não acaba com os imprevistos, nem garante um cronograma em dia, mas resultados empíricos mostram que uma técnica adequada e a experiência do planejador contribuem para melhores estimativas.</p><p>Uma outra abordagem indicada pelos autores e especialistas em estimação é medir e armazenar a produtividade da equipe para então projetar os resultados futuros. Individualmente, este é um dos principais objetivos do <a href="http://pt.wikipedia.org/wiki/Personal_software_process">PSP</a> (<em>Personal Software Process</em> ou Processo de Software Pessoal). Um dos pilares do Scrum, a <a href="http://blog.myscrumhalf.com/2013/04/os-pilares-do-scrum-inspecao/">Inspeção</a>, deve permitir acompanhar o progresso e a produtividade da equipe.</p><p>Embora a estimação, tanto dos testes quanto das demais atividades do desenvolvimento de software, seja uma tarefa mais de intuição do que um processo científico, em geral observa-se uma melhora na qualidade das estimativas com o uso sadio de dados históricos e analogia das atividades novas com as já executadas.</p><p>Uma aplicação prática disso para os testes é muito simples. Imagine um cenário onde você entregou a versão inicial do produto e irá partir para a segunda fase de um projeto de N fases. Se você mediu o tempo gasto com os testes na primeira fase, calcule o desvio com relação ao tempo planejado e aplique-o no planejamento da segunda fase. O processo deve ser repetido a cada fase do projeto.</p><p>Note que isso é compatível com o conceito do <strong>Cone da Incerteza</strong>, o qual afirma que as estimativas são melhores a cada fase do projeto. Considere a imagem abaixo, extraída <a href="http://www.infoq.com/br/news/2011/10/estimativas-comprometimento">deste artigo</a>):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/479/1*sfSOqo1C6A8KbJcR1fAPNQ.png" /></figure><p>Na medida em que o projeto se desenrola, em tese, podemos analisar com mais certeza o horizonte de sua conclusão. No entanto, a curva não é a mesma para todo projeto e empresa. <strong>Os autores afirmam que a curva acima é o caso ótimo e se não houver gerenciamento adequado a incerteza continuará grande mesmo na data de término do projeto!</strong></p><h3>Estimação em faixas</h3><p>Isso nos leva a outro conceito: <strong>estimar em faixas de valores</strong>. Podemos usar esta técnica para estimar o <strong>melhor</strong> e o <strong>pior</strong> caso para uma determinada atividade. A diferença entre esses casos corresponde à incerteza atual.</p><p>Tenho usado faixas de valores para trabalhos como consultor independente e tem funcionado bem, principalmente em atividades que envolvem algo novo para mim, portanto não sei ao certo quanto tempo será necessário de pesquisa, desenvolvimento e testes.</p><p>Em um exemplo simples, posso responder que a atividade poderá levar de 8 a 12 horas. Se tudo correr bem, pode ser até menos. Se tudo der errado, talvez eu tenha que negociar horas a mais. Na maioria das vezes consigo acertar e cobro algo dentro da faixa.</p><p>Isso também permite ajustes relacionados a reuniões e telefonemas. Se em um projeto passei duas horas ao telefone com o cliente, esse tempo é incluído no tempo da atividade. Se o cliente especificou bem a tarefa e não foi necessário muito tempo de análise, bom para ele, vai pagar menos.</p><p>É claro que isso envolve uma relação de confiança por parte dos clientes, mas a ética do profissional cedo ou tarde torna-se patente.</p><h3>Estimativa ou compromisso?</h3><p>Outro erro comum no dia-a-dia é confundirmos estimativas com compromisso por parte dos desenvolvedores.</p><p>Imagine que uma empresa estima os testes com uma regra mágica de 50% do tempo de desenvolvimento. Os desenvolvedores percebem que estão gastando muito mais do que isso.</p><p>Uma reação comum para não “atrasar o cronograma” é simplesmente escrever menos testes do que o planejado, como se a estimativa inicial fosse uma obrigação a ser seguida.</p><p>O correto seria revisar a estimativa inicial e não tentar se ajustar a ela. O problema é que na prática…</p><blockquote><em>Frequentemente falta aos gerentes de software firmeza de fazer o pessoal esperar por um bom produto (Brooks)</em></blockquote><h3>A qualidade é um fator determinante</h3><p>Usei a citação acima em um <a href="http://luizricardo.org/2013/09/entendendo-o-triangulo-de-ferro-porque-nao-podemos-ter-tudo/">artigo sobre o Triângulo de Ferro</a> que escrevi há algum tempo. Este conceito é importante pois demonstra que a qualidade possui uma relação direta e proporcional com o tempo despendido no projeto.</p><p>Isso implica em afirmar que <strong>mais qualidade exige mais tempo</strong>. Por isso, <strong>a decisão de investir em mais ou menos testes no início do projeto influenciará diretamente na qualidade final do produto</strong>.</p><h3>Diminuindo o tempo despendido com testes sem prejudicar a qualidade</h3><p>O título parece contradizer o que acabei de dizer. Mas, se tomarmos o conceito de separação entre atividades essenciais e acidentais do desenvolvimento como faz Brooks em <a href="http://en.wikipedia.org/wiki/No_Silver_Bullet"><em>No Silver Bullets</em></a>, podemos dizer que, <strong>embora não haja como evitar os testes sem diminuir a qualidade, podemos diminuir as dificuldades acidentais da criação deles</strong>.</p><p>Isso pode ser alcançado de algumas formas:</p><ul><li>Treinando a equipe para melhorar a produtividade;</li><li>Usando ferramentas mais adequadas que facilitem a criação e execução dos testes;</li><li>Investindo na automação;</li><li>Usando tecnologias (frameworks, plataformas) que facilitem os testes.</li></ul><p>Enfim, podemos ser <strong>mais produtivos fazendo mais testes e menos trabalho repetitivo manual</strong>.</p><p>Este artigo foi originalmente criado por Luiz Ricardo e está hospedado em seu site no endereço <a href="http://luizricardo.org/2014/03/quanto-tempo-gastar-com-testes/">http://luizricardo.org/2014/03/quanto-tempo-gastar-com-testes</a>.</p><p>Siga-o no linkedin: <a href="https://www.linkedin.com/in/utluiz/">https://www.linkedin.com/in/utluiz/</a></p><p>Acompanhe as novidades da QA School também lá no Linkedin: <a href="https://www.linkedin.com/company/qaschoolbr/">https://www.linkedin.com/company/qaschoolbr/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71abc4f768a2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Use Hashes em vez de Case Statement]]></title>
            <link>https://medium.com/@qaschool/use-hashes-em-vez-de-case-statement-2316437470ea?source=rss-31bdb5355af0------2</link>
            <guid isPermaLink="false">https://medium.com/p/2316437470ea</guid>
            <dc:creator><![CDATA[QA School]]></dc:creator>
            <pubDate>Mon, 08 Jun 2020 02:30:23 GMT</pubDate>
            <atom:updated>2020-06-08T02:30:23.140Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*mZIy0lTs9e4HKeJPSqoXEg.png" /></figure><p>Você já pensou como seria um código repleto de blocos condicionais no Ruby? Imagine ter de criar inúmeras comparações de casos utilizando IF ou Case Statements? Nada produtivo, concorda?</p><p>Veja o exemplo a seguir:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee8b6e6373b7e9390b09aa954bf1894c/href">https://medium.com/media/ee8b6e6373b7e9390b09aa954bf1894c/href</a></iframe><blockquote><em>Fazendo uso de Hashes a vida fica um tanto mais fácil. Por isso, aprenda agora como parar de usar diversas comparações </em><strong><em>IF-ELSE</em></strong><em> e </em><strong><em>CASE-WHEN-THEN</em></strong><em>.</em></blockquote><p>Mas antes, vejamos uma pequena refatoração meio que aceitável quando ainda não se conhece a melhor prática.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/35b157fa1d690828c97cc9d2fc6adaf7/href">https://medium.com/media/35b157fa1d690828c97cc9d2fc6adaf7/href</a></iframe><p>Agora vamos partir para a melhor prática com o uso de Hashes. Preparad@s?</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7530bf458c6d26af8573b081bb4b95c0/href">https://medium.com/media/7530bf458c6d26af8573b081bb4b95c0/href</a></iframe><p>Caso queira se aprofundar mais, veja o <a href="https://franzejr.github.io/best-ruby/refactorings/case_with_hashes.html">conteúdo</a> original.</p><p>Para finalizar, mais um exemplo do uso de Hashes a fim de tornar o código mais enxuto, legível e mais funcional.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/12beb2bead2e18c42800ff4dda39f337/href">https://medium.com/media/12beb2bead2e18c42800ff4dda39f337/href</a></iframe><p>Gostou da dica? Então acompanhe a QA School no <a href="https://www.linkedin.com/company/qaschoolbr">Linkedin</a> e no nosso grupo exclusivo do <a href="http://t.me/qaschoolbr">Telegram</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2316437470ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>