SyntaxHighlighter

domingo, 13 de setembro de 2015

O que é Ciclo de Vida do Defeito ou Bug em Testes de Software?

O ciclo de vida do defeito ou bug ocorre sempre que um defeito é identificado durante o ciclo de vida da aplicação e termina quando o defeito tem seu estado alterado para 'fechado' após ser confirmada a sua correção. Lembre-se: o Ciclo de vida do defeito é relacionado ao bug encontrado durante os testes.

Bugginho Developer

O bug tem estados diferentes dentro do ciclo de vida, o que pode ser mostrado na figura abaixo:
Ciclo de Vida de um defeito
O ciclo de vida do Defeito ou do Bug incluem os seguintes passos ou estados:
  1. New (Novo): Quando um defeito é identificado e cadastrado na primeira vez. Seu estado é dado como Novo,
  2. Assigned (Atribuído): Após o testador ter cadastrado o defeito, seus Gerente verifica se esse defeito é realmente novo e então atribui o defeito para que o desenvolvedor e seu time possa corrigí-lo. Seu estado é dado como Atribuído.
  3. Open (Aberto): Neste estado, o desenvolvedor já começa a análise e o trabalho para a correção do defeito.
  4. Fixed (Corrigido): Quando o desenvolvedor faz alterações no código, então, ele muda o estado do Bug para 'Corrigido' e o passa ao Time de Testes.
  5. Pending retest (Pendente Reteste ou Revalidação): Após corrigir o defeito, o desenvolvedor entrega essa alteração para que o testador refaça o teste. Neste caso, o teste está pendente aguardando o fim do teste, logo, seu estado é pendente reteste.
  6. Retest (Reteste): Neste estágio, o testador começa a fazer o reteste da alteração feita pelo desevolvedor, que repassou ao tester para reteste. É neste estágio que o testador informa ao desenvolvedor se o defeito foi corrigido ou não.
  7. Verified (Verificado ou Validado):  O testado testa novamente a correção após ele ser corrigido pelo desenvolvedor, se o defeito não for mais localizado no Software, então, o testador informa que o defeito foi consertado e muda o estado para "Validado" ou "Verificado".
  8. Reopen (Reaberto): Se o defeito ainda existir mesmo após o mesmo ter sido corrigido pelo desenvolvedor, o testador muda o estado para 'Reaberto', Então, o defeito inicia todo o ciclo de vida novamente.
  9. Closed (Fechado):  Uma vez que o defeito foi corrigido, testado e verificado que o Defeito não mais existe, o testador muda o estado para 'Fechado'. Este estado informa que o defeito está corrigido, testado e aprovado.
  10. Duplicate (Duplicado): Se o defeito é repetido ou existe mais de menção do mesmo defeito, então um desses defeitos recebe o estado de "duplicado".
  11. Rejected (Rejeitado): Se o desenvolvedor identificar que o defeito não é novo, ele rejeita tal defeito. Então, seu estado é modificado para "Rejeitado".
  12. Deferred (Postergado): O defeito quando tem seu estado alterado para "Postergado" é porque ele será corrigido em versões futuras do software. As razões para isso, é que o defeito pode ser de baixa prioridade, falta de tempo ou o defeito pode não causar sérios danos ao funcionamento do Software e com isso, pode ser postergado.
  13. Not a bug (Não é um defeito):  Esse estado é dado para o defeito quando não existir qualquer alteração nas funcionalidades da aplicação. Por exemplo: se o cliente pergunta sobre alguma alteração na parte visual ou nas disposições dos campos como a troca de cor de algum texto, isso não é um defeito, apenas houve uma mudança não informada no design da aplicação.
Fonte: ISQTB

quarta-feira, 9 de setembro de 2015

4. Técnicas de Modelagem de Testes - O que é análise de Teste? Ou como identificar as condições para o Teste?

Análise de Teste: Identificando condições para teste
A análise do teste é o processo que procura por algo que possa ser convertido em informações para teste. Também é chamada de Base do Teste.
  • A base do teste é a informação necessária para começar a análise do teste e criar nossos próprios casos de teste. É uma documentação na qual casos de teste são baseados, tais como requisitos, especificações de projeto, análises de risco de produto, arquitetura e interfaces com o usuário.
  • Podemos utilizar os documentos da base de teste para compreender o que o sistema fará quando for construído. Em alguns casos, os testes pode se basear no conhecimento que o usuário tem do sistema e isso pode não estar documentado.
  • Da perspectiva do teste, nós olhamos a base de testes para ver o que pode ser testado. Essas são as condições de teste.  Uma condição de teste é algo que nós podemos testar.
  • Enquanto identificamos as condições de teste ideal dentro das muitas condições que temos e então selecionar quais delas serão realmente úteis em nossos casos de testes, a isso chamados de possibilidade de teste.
  • Como já é sabido, testar tudo no sistema é impraticável, tal procedimento é chama-se teste exaustivo. Devemos escolher apenas um conjunto dos testes possíveis. Na prática, tal conjunto pode ser pequeno diante do tamanho sistema, porém, ele tem uma grande probabilidade de encontrar a maioria dos defeitos.
  • Precisamos de muita inteligência no processo para organizar nosso conjunto e a essa inteligência damos o nome de técnicas de teste. As condições para teste que foram escolhidas, vão depender da estratégia de teste ou de uma abordagem de teste mais detalhada. Por exemplo, precisam ser baseados no risco, modelos de sistema e etc.
  • Uma vez identificada a lista de condições para o teste, é muito importante priorizá-los, então a condições mais importante será identificada. Tais condições podem ser identificadas por dados de testes bem como para entradas e para saídas, por exemplo diferentes tipos de registros, diferentes tamanhos de registros ou campos em um registro. As condições de teste estão documentadas na IEEE 829 que se chama "Especificação de Modelagem para Testes".
Fonte: ISTQB

terça-feira, 8 de setembro de 2015

Como passar no Exame de Certificação de Testes Foundation da ISTQB/BSTQB (CTFL) de primeira like a boss ou like a Messi

Aqui temos algumas dicas e macetes para passar no Exame de Certificação Nível Foundation (CTFL) da BSTQB/ISTQB.
Bem, fazendo pela BSTQB, em português,o resultado demora 6 dias para ser divulgado, já se fizer na ISTQB o resultado sai na hora... por acaso alguém já conhece a piada sobre o Inferno Brasileiro? é quase a mesma coisa.
  1. Estude todo o Syllabus do Foundations. Vamos cobrir, ou pelo menos tentar, todo o Syllabus em nosso  Blog. Os Tópicos, 5 no total, são explicados de maneira própria dentro de cada assunto e suas terminologias que caem normalmente no exame.
  2. Após ler todo o conteúdo do Syllabus corretamente, faça alguns simulados e responda à questionários. Você pode fazer alguns aqui. Uma outra dica muito importante: Nunca estude inicialmente pelos simulados, isso pode causar mais confusão do que auxílio, tente seguir à risca essa receitinha de bolo, que você vai se dar bem.
  3. Fazer o simulado te dará uma idéia dos tópicos que vão precisar de mais atenção. Também vai te ajudar a entender as diferentes perguntas que são feitas.
  4. Após resolver algumas questões dos questionários ou simulados, volte ao Syllabus e leia-o novamente. Sim, isso mesmo, leia-o novamente, é muito importante.
  5. Isso vai te ajudar a entender os tópicos e as terminologias de uma forma melhor e você terá uma melhor compreensão dos tópicos.
  6. Você também pode fazer uma lista de terminologias e as definições que caem normalmente no Exame, através dos simulados.
  7. Você precisar ter bastante atenção à alguns tópicos como teste de Caixa Preta (Partição de Equivalência, Análise de Valor Limite), teste de Caixa Branca, teste de Cobertura e Tipos de Cobertura com cobertura de Declaração, cobertura de Decisão e cobertura por Condição.
  8. Após ler todo o syllabus duas vezes e resolver alguns questionários, tente fazer um simulado dentro do tempo de prova, ou seja, 40 questões dentro de 60 minutos.
  9. Isso significa que você terá 1,5 minutos,ou um minuto e meio, para responder cada questão. Esse tempo é suficiente para resolver perguntas de múltipla escolha.
  10. Candidatos conseguem se preparar em até dois meses ou menos, mesmo trabalhando e com suas esposas a TPM. 
Algumas dicas à respeito das questões do exame:

  1. As questões são apresentadas de um modo em que todas as opções são bastante parecidas. Então, é muito importante, estar relaxado e ler a questão e suas opções com muito cuidado..
  2. Se você encontrar mais de uma resposta correta, então comece eliminando as óbvias, após fazer isso, foque-se na terminologia ou definição ou resposta e então faça a marcação correta.
  3. Leia a questão duas ou três vezes e tente compreendê-la. Existem algumas palavras na questão que precisam de maior atenção como "NÃO", "NUNCA","TODOS","TUDO" e etc.
  4. Após responder as questões do simulado, verifique as suas respostas e veja a sua pontuação. Você precisa resolver 26 questões corretamente, no mínimo, para passar no exame.
Desde que você tenha lido todo o Syllabus por duas ou três vezes e resolvido 20 à 30 questionários em um tempo estimado. Eu acho que você está pronto para fazer o exame e passar de primeira Like a Boss.
Mas, se mesmo assim você não se sentir seguro, você pode fazer um curso excelente aqui

E aí, você vai me perguntar:
- Gabriel, e o Teste de Caixa Cinza, o famigerado Grey Box?
E eu vou responder com o maior prazer:
- Grande amigo, esse negócio de Grey é coisa de Teoria da Conspiração, Área 51, isso é com o pessoal do Arquivo X. E agora tem umas Testers ai que só querem saber de 50 Testes de Caixa Cinza... melhor a gente não tocar muito nesse assunto não... Véi na boa! Isso nem está na documentação da ISTQB, porque Grey Test é um híbrido tipo o Chupacabras,Optimus Prime... essas coisas!
E mais uma vez: The treta has planted!
Fonte: ISTQB

segunda-feira, 7 de setembro de 2015

Quais são as fases do Ciclo de Vida de Desenvolvimento de Software (SDLC) ?

Essa é para puxar na memória.
Lembra quando você tinha essa matéria, que era decoreba, na faculdade ou no curso tecnico de processamento de dados? (Caramba! Curso de Processamento de Dados... acho que entreguei a minha idade agora!).
Pior que tinha sempre um professor que as colocava fora de ordem e na multipla escolha tínhamos que acertar qual a ordem certa, mas tinha sempre aquela maldita opção das "N.R.A."  - Nenhuma das Respostas Acima, pois é...
Hoje em dia, por mais que você a ignore, ela tem um peso muito grande.
Gigantes como a Microsoft estão focando suas equipes e aplicativos em frameworks que facilitam o SDLC, porém, com um outro nome: o ALM (Application Lifecycle Management) - Gerencimento do Ciclo de Vida da Aplicação. O nome ficou mais bonito e pomposo, mas na prática é a mesma coisa. A única grande novidade é que, na Microsoft com o Team Foundation Server, você pode escolher entre utilizar CMMI, Agile ou Scrum para gerenciar o seu trabalho. Mas, isso é assunto pra um outro artigo, quando eu abordar um ALM completo com TFS e depois um ALM completo totalmente Open Source, com Jenkins.
Se você ainda está na faculdade e está às voltas com essa sigla, que você acha que tem parte com o Capiroto, fique tranquilo, vamos exorcizar essa pobre alma em algumas linhas abaixo.
Existem várias abordagens definidas e projetadas para desenvolvimento de Software que são utilizadas/empregadas durante o processo. Tais abordagens também são definidas como Modelos de Processos do Desenvolvimento de Software, por exemplo, temos o Modelo Cascata, Modelo Incremental, Modelo V, que não é o de Vingança, o Modelo Iterativo e etc etc). Cada modelo de processos segue um ciclo de vida específico na sua forma de produzir sucesso, ou fama lê-se Martin Fowler, no desenvolvimento de software.
Os modelos de ciclo de vida do Software descrevem suas fases e a ordem nas quais devem ser executadas. Cada fase produz entregáveis necessários para que a próxima fase tenha início, ou seja, são fases dependentes - pegando um pouquinho de carona com o pessoal PMI na veia. Requisitos são traduzidos em Modelagem. Código é produzido de acordo com a modelagem - pelo menos deveria - no que é chamada de fase de desenvolvimento. Após Codificar, os "Codar", os testes de verificação do produto final para verificar se estão de acordo com o que fora levantado, se sim, então podemos "subir" a aplicação em Produção, que é quando o usuário vai poder utilizar o Sistema e fazer os milagres que sempre faz em encontrar erros e também dizer "pior que isso funciona!".
É verdade que listamos muitos modelos, mas você vai me perguntar: 
- Gabriel, você tá doidão? e o Scrum, XP e outras abreviações ágeis?
A minha resposta será: 
- Estão no Desenvolvimento Iterativo!
The treta has planted!
Apesar da treta estar plantada, existem 6 fases padrão, pelo menos por enquanto, em todo ciclo de vida de desenvolvimento de um Software, o SDLC ou o ALM da Skynet e do Ultron não contam:

  1. Levantamento de Requisitos e Análise
  2. Modelagem
  3. Implementação ou Codificação - (É  a gente mesmo!)
  4. Testes - (É nóis na fita, ladrão!)
  5. Publicação ou Implementação em Produção
  6. Manutenção ou Sustentação
1) Levantamento de Requisitos e análise: Requisitos do Negócio são levantados nessa fase. Essa fase é o foco principal dos colaboradores e dos gerentes de projeto e dos POs também  - pros agilistas ficarem no meu blog. - Entrevistas com gerentes, colaboradores envolvidos no negócio e usuários de todos os tipos e espécies em seu habitat natural, todos são colocados em fila para determinar, inspecionar e nos ensinar cada vez melhor , veja bem! - sobre as Regras de Negócio envolvidas, tais como: Quem vai utilizar o Sistema? Quais dados serão inseridos no Sistema? Quais dados o sistema irá mostrar aos usuários? Estas são perguntas gerais que devem ser respondidas durante a fase de levantamentos de requisitos (É, realmente deveriam né? mas a realidade... bem, a realidade... xá pra lá!). Após o levantamento de requisitos, estes são analisados, validados e é estudada a possibilidade do que deve ou não ser incorporado aos requisitos do sistema a ser desenvolvido.
Finalmente, é... ainda não acabou, um documento de Especificação de Requisitos é criado e serve (uhum, sei!) como guia para as próximas fases do Modelo.
Diante do que foi dito nessa primeira fase, você já notou como tudo fica mais difícil quando um requisito é mal modelado ou quando uma Estória de Usuário é entregue sem Regra de Aceitação ou quando uma Regra de Aceitação é mal feita ou a própria Estória de Usuário na verdade é um Épico e você não compreendeu? Olha bem o quanto de dinheiro é gasto nessa fase e quanto que se ainda vai gastar caso algo dê errado. Pensa aí e depois coloca lá nos comentários, vamos debater sobre isso.
2)  Modelagem: Nessa fase, o produto e o ambiente, são modelados e projetados de acordo com as especificações de requisitos estudadas e informadas na fase 1. O projeto do sistema ajuda a especificar o hardware e os requisitos também auxiliam no geral à Arquitetura do Sistema - não existe almoço grátis. As especificações de projeto e modelagem de sistema servem como entrada para a próxima fase.
3)  Implementação ou Codificação: Ao receber os documentos de modelagem, o trabalho é dividido em módulos/unidades e a codificação atual é iniciada. Assim que esta fase começa a produzir o código propriamente dito, o foco principal é para o desenvolvedor. Essa é a fase mais longa do ciclo de vida do desenvolvimento de software, para quem não acredita, aqui vai uma estorinha "das trincheiras" que tá na moda: Imagine que Deus (Gerente de Projetos) avisa pra você que a humanidade vai acabar ("cara, esse projeto é de emergência") e ainda te avisa que vão chover 40 dias e 40 noites ("... esse projeto tem muita gente graúda, precisamos entregar isso logo senão estamos fritos...") e então te manda construir uma arca ("Cara, faz de um jeito rápido que dê pra entregar e tá bom. Rodou... Xablau!") e aí vem a chuva, quando você ainda está terminando os testes de aceitação, mas o XGH  - Extremme Go Horse - é quem manda e o resto você já sabe né... não é à toa que essa fase 3 é a mais demorada. Em alguns lugares ela dura por anos... (o grifo é nosso).
4)  Teste:  Após o código ser desenvolvido, ele é testado de acordo com o que está escrito nos requisitos, aí que começa o "sapeca iá iá", para verificar se o Produto está realmente resolvendo os problemas dos quais fora contratado para resolver nas fases anteriores, o que significa, que se tudo der certo, saber também se a equipe de desenvolvimento vai ganhar uma PLR gorda no final do ano ou um Cestão (ferrados! é claro). Durante essa fase, todos os testes que a mente maligna e criativa do tester criar serão utilizados: Teste unitário, Teste de Integração, Teste de Sistema, Teste de Aceitação e dentre outros. Não especifiquei todos porque estou escrevendo antes de dormir e não quero ter pesadelos.
5)  Publicação em Produção: Ufa! depois que nosso trabalho sobreviveu a fase de testes, vamos faturar. O produto é entregue e publicado em produção para que o cliente o utilize.
6) Maintenance: Mas, nem tudo são flores e quando os clientes começam a utilizar o sistema de forma massiva, e é aí que eles fazem cada coisa...operam verdadeiros milagres, até cheat codes utilizam, então os problemas começam a aparecer e precisam ser solucionados de tempos em tempos.  Tal processo, onde damos um carinho e uma amolecida no nosso produto desenvolvido, é mais conhecido como Manutenção ou Sustentação, mas o usuário teima em chamar de Porcaria, fazer o quê?

Fonte: ISTQB

Qual o significado de Defeito, Bug ou Erro e Falhas em Teste de Software?

Um regrinha rápida para compreender:
1) Erro é cometido por um ser humano
2) um Defeito é gerado no Sistema, quando programado de forma errada.
3) Falha é o que é retornado para o usuário através de um aviso na tela.
4) Bug é quando uma grande quantidade de erros, defeitos ou falhas são encontrados no Software. 
Para evitar essa dor de cabeça quando o seu Produto de Software for entregue, é muito útil que se use o Teste de Software, como já dissemos, durante todo o seu ALM.
Agora, vamos de definição.

Definição:
  • Um defeito é um erro ou um bug, dentro da aplicação quando ela é criada. Um desenvolvedor quando está modelando e construindo o Sistema, pode cometer enganos ou erro. Esses enganos ou erros significam que existem falhas no Sistema, tais falhas são chamadas de defeitos.
  • Quando o resultado atual desvia do resultado esperado durante os testes então isso é um defeito. Consequentemente, qualquer desvio da especificação mencionado no Documento de Especificação funcional do produto é considerado um defeto. Em empresas diferentes isso é frequentemente chamado de bug, issue, problema ou incidente.
  • Quando a Produto final não supre a expectativa do usuario final ou não respeita os Requistos Modelados, então isso resultado em um Bug ou Defeito. Esses defeitos, ou bug, ocorrem porque houve um erro de lógica ou erro no código que resulta em uma falha ou resultado imprevisivel ou imprevisto.
Informações adicionais sobre Defeitos/Bugs:

Quando uma aplicação ou um Produto de Software é testado, se um grande número de defeitos são encontrados então ela é considerada "Bugada" ou que contém um "Bug".
Quando um testador encontra um Bug ou um Defeito,é necessário informar sobre os mesmos com os desenvolvedores. Para tal, ele coloca tais defeitos em um Relatório detalhando os passos efetuados até chegar no defeito encontrado, esse Relatório tem vários nomes: Relatório de Bugs, Relatório de Issues, Relatório de Defeitos, Relatório de Problemas e etc.
Este Relatório consiste, basicamente, em conter a seguinte informação:
  • ID do Defeito – Todo Bug ou Defeito tem um número de identificação único.
  • Descrição do Defeito – A explicação sobre o que foi encontrado.
  • Versão do Produto – A versão do Produto, aplicação, no qual o defeito é encontrado.
  • Detalhes Passo a passo – Os passos detalhados do problema com prints de tela anexados para que os desenvolvedores possam simular o mesmo em seu ambiente.
  • Data do Ocorrido – A data de quando o Bug foi encontrado e relatado.
  • Reportado Por – As informações do Testador que encontrou e reportou o Problema, tais como o nome e o Id do Testador.
  • Estado – O Estado do defeito como: Novo, Encaminhado à alguém, Aberto, Retestado, Verificação, Fechado, Falho, Igorado ou Deferred e etc.
  • Corrigido por – Os detalhes do desenvolvedor que corrigiu o defeito como Id e Nome do Desenvolvedor.
  • Data de Finalização – A data em que o defeito foi resolvido e a entrada finalizada.
  • Severidade – Baseado na severidade (Crítica, Principal, Menor), nos diz sobre o impacto do defeito ou bug na aplicação.
  • Prioridade – Baseado em um conjunto de prioridades (Alta, Média, Baixa), a ordem de corrigir o defeito pode ser dada.
Fonte: ISTQB

1. Fundamentos de Teste - 1. O que é Teste?

Teste de software é o processo de executar uma aplicação com a intenção de encontrar bugs. Também pode ser definido como o processo de validação e verificação feito em um software:


  • Atende aos requisitos técnicos e de negócios que orientaram seu design e desenvolvimento.
  • Trabalha como esperado.
  • Pode ser implementado com características similares.

Colocando uma Máquina de Raios-X sobre a definição de Teste de Software, a vemos em partes, como já dizia Jack:

1)  Processo:  Testar é um processo, e esse processo é melhor do que uma atividade única, ou fazer algo de uma única vez e validar no final.
2)  Ativo em todo o Ciclo de Vida: Teste é um processo que é executado durante todo o Ciclo de Vida da Aplicação (ALM).
  • O processo de modelagem dos testes, desde o inicio e durante o ciclo de vida, pode ajudar a prevenir defeitos antes que estes sejam introduzidos no código. Algumas vezes é definido como “verificação da base de testes de acordo com a modelagem do Sistema.”
  • A Base de Testes inclui documentos, tais como as especificações de Requisitos e de Modelagem da aplicação.
 3)  Teste Estático: Quando executado, pode encontrar defeitos sem precisar executar o código. O Teste Estático inclui revisão de documentos (incluindo código fonte da aplicação) e análise estática de código. É um teste útil e barato. Esse tipo de teste é muito executado pelas IDEs modernas como Visual Studio, Eclipse, NetBeans e afins, para ver na prática, basta errar alguma palavra reservada da linguagem  ou algum comando que a IDE vai sublinhar o erro e com isso evitando que a aplicação seja montada e executada até que o erro seja corrigido.
4)  Teste Dinâmico: Em um teste dinâmico, o código fonte que precisamos testar é executado, ou "rodado", para demonstrar como ele responde. É feito durante o processo de validação. Exemplos de testes dinâmicos: teste unitário, teste de integração, teste de sistema e etc.
 5)  Planejamento:  Precisamos planejar o que queremos fazer. Controlando as atividades do teste, informando o progresso do teste e o estado do sistema durante os testes, ou seja, como o sistema responde durante essa tarefa, é muito importante anotar tudo o que se encontra e depois fazer uma reunião para selecionar que informação realmente importa ou não.
6)  Preparação:  Precisamos escolher qual tipo de teste faremos, escolhendo as condições para teste e modelando os casos de teste.
7)  Avaliação: Durante a avaliação, precisamos checar os resultados e avaliar o software sob nossa responsabilidade e os critérios de compleição, critério de "passou", "falhou" ou "inconclusivo", que nos ajuda a decidir quando terminar de testar e se o produto passou nos testes propostos.
8)  Produtos de Software e artefatos de resultado gerados:  Junto com o teste de código, os testes de Requisitos e as especificações de modelagem e outros documentos relacionados ao usuário, materiais de treinamento são muito importantes.
Fonte: ISTQB

segunda-feira, 4 de agosto de 2014

Integração Contínua em .NET – Parte I

Automatizando seus Processos de Construção, Compilação, Testes, Documentação e Implementação de seus Sistemas em .NET

Nesta primeira parte de nossa série sobre Integração Contínua – mais conhecida na comunidade como CI, o leitor aprenderá sobre o aspecto técnico e psicológico em implementar o conceito de Integração Continua e as vantagens e desvantagens de implementá-la nas organizações vencendo as objeções que aparecem durante o processo até a sua adoção em definitivo.
Nesta Série, nós também introduziremos o leitor com o uso muitas ferramentas gratuitas e de baixíssimo custo tais como Subversion, MSBuild, NAnt, Jenkins e CruiseControl.NET que são partes de um processo completo de Integração Contínua e demonstraremos em detalhes como usar estas ferramentas,neste artigo demonstraremos um processo de Integração Contínua simples. Vamos criar um pequeno Sistema de aprovação de execução de builds que nos dará um maior controle para que nossas alterações sejam publicadas em ambientes estáveis de desenvolvimento, Homologação e Produção. Criaremos um Estudo de Caso que será levado à efeito com o uso da Integração Contínua ao longo desta série. Contaremos o caso da Empresa de Software Fictícia Imbróglio de Códigos LTDA e como a mesma conseguiu se salvar da falência total implementando lentamente o que chamamos de Os 7 Ciclos do Sucesso para a Integração Contínua.

Como desenvolvedores,  estamos interessados em desenvolver nossas aplicações da melhor forma possível para os nossos clientes como um minimo de esforço. Mas, nos tempos atuais, com aplicações mais complexas e tendo cada vez mais "partes móveis", criar grandes aplicações está se tornando cada vez mais difícil, mesmo com o avanço nas ferramentas de desenvolvimento, tais como o Visual Studio e .NET Framework. Uma das chaves para a melhoria da produtividade,e consequentemente das aplicações entregues, é a automatização da parte  repetitiva do trabalho e a Integração Contínua é uma das melhores formas de se fazê-lo.
Não podemos crer que o Processo de Integração Contínua seja a bala de prata ou a solução para todos os males, mas onde ela tem sido implementada, tem tido grande sucesso e melhorias no processo de software para as equipes de desenvolvimento.
A Integração Contínua, também conhecida como CI - Continuous Integration - é o ponto central do desenvolvimento de software atualmente. De fato, quando a CI é introduzida em uma empresa, torna-se o grande divisor de águas, ela altera radicalmente a forma como as equipes pensam sobre todo o processo de desenvolvimento. A CI tem o potencial de permitir e executar uma série de melhorias contínuas e incrementais nos processos, indo de um processo de simples agendamento de construção - vamos usar o termo build – até o processo de Entrega Contínua que culmina no processo de publicação nos demais ambientes para Teste, Homologação ou Produção.
Uma boa infraestrutura que possibilite a Integração Contínua pode simplificar o processo de desenvolvimento até a entrega do software ou de sua iteração, auxiliando a identificação e correção de  falhas rapidamente. Também facilita a disponibilização de uma dashboard muito útil no Projeto tanto para desenvolvedores quanto para outros profissionais da empresa que não são desenvolvedores e, ultimamente, ajuda equipes a agregar mais valores ao negócio e ao produto sendo desenvolvido para o cliente. Todo time de desenvolvimento, não importando se grande ou pequeno, deve implementar e pensar como Integração Contínua.

O que é a Integração Contínua?

Voltando aos dias dos Projetos desenvolvidos utilizando a Metodologia em Cascata e controlando os cronogramas com gráficos de Gantt, bem antes da introdução das práticas de Integração Contínua, o tempo e a energia da equipe de desenvolvimento era drenada diretamente para um procedimento chamado de Fase de Integração, que era executado sempre um passo anterior à entrega do software. Durante esta Fase, a alteração do código era feita por alguns desenvolvedores ou pequenos times que eram reunidos de forma isolada e se juntavam apenas na integração de todo o trabalho já feito. Era um trabalho complicado, na maioria das vezes durava meses, em uma integração com mudanças de código conflitando entre si. Era muito dificil antecipar quais tipos de problemas iriam ocorrer durante este processo e era ainda mais oneroso corrigir os erros provenientes de tais integrações pois envolviam quase sempre retrabalho e reengenharia de código criado meses ou semanas antes. Este processo complicado, oneroso e doloroso, cheio de riscos e perigos, frequentemente causava um grande atraso na entrega, custos não planejados e, como resultado de tudo isso: clientes insatisfeitos. A Integração Contínua nasceu para resolver estes problemas e sanar estas dificuldades. Na sua forma mais simples, a CI envolve ferramentas que monitoram seus Sistema de Controle de Versão (Box 1) buscando sempre alterações. Logo que uma alteração no código é identificada, O Servidor automaticamente compila e testa o código de sua aplicação. Se algo dá errado, a ferramenta imediatamente notifica os desenvolvedores para que eles possam corrigir o problema imediatamente. Mas, a Integração Contínua pode fazer muito mais do que isso.

Sistema de Controle de Versão (SCM).
É um software que tem como principal funcionalidade, controlar versões de um documento qualquer,ou seja, cada alteração que é feita neste documento, se torna uma versão deste e o SCM controla de forma sequencial tais versões. Tal software é muito utilizado em ambientes de desenvolvimento seja ele corporativo ou não.

A Integração Contínua pode também ajudar a equipe a manter a saúde do seu código, monitorar automaticamente a qualidade de código e as métricas em seu código e desta forma auxiliar a manter a Dívida Técnica (Box 2) controlada e os custos de manutenção baixos.

Dívida Técnica.
Dívida Técnica descreve a dívida que a equipe de desenvolvimento assume quando escolhe um design ou abordagem fácil de implementar no curto prazo mas com grande impacto negativo no longo prazo.
A visibilidade pública das métricas de qualidade de código encoraja os desenvolvedores a terem um maior cuidado quanto à qualidade de seu código e melhorá-lo, devemos lembrar que o principal fundamento da Integração Contínua não é punir, mas sim facilitar a manutenção do código afinal de contas o código é de todos. Combinando testes de aceitação, a CI pode também funcionar como uma ferramenta de comunicação, mostrando um verdadeiro Raio-X do estado atual do Projeto em andamento dentro e fora da equipe. Pode simplificar e acelerar a entrega auxiliando a automação do processo, deixando a publicação da última versão da aplicação totalmente automática ou permitindo a operação com apenas um aperto de botão. Em sua essência, a Integração Contínua age sempre na redução de riscos à aplicação e seu desenvolvimento nos dando uma resposta rápida.
Desta idéia, tiramos então uma conclusão lógica: precisamos sempre enviar qualquer alteração de nosso código para teste antes de entrar em produção. De certa forma, o uso da Entrega Contínua, está intrinsecamente ligado a Integração Contínua, posto que esta termina e começa aquela que nada mais é do que automatizar uma implementação do website, devolver um módulo pronto ou outra atividade de fim pois a Integração Contínua é atividade de meio. Então, uma abordagem pura da Integração Continua pode não ser apropriada para todas as equipes. Um exemplo disto, é que muitos usuários não vêem com bons olhos novas versões de software sendo entregues muitas vezes em uma semana e com isto as solicitações para que os mesmos façam seus testes de aceitação e acabam por preferir um ciclo mais espaçado e com um prazo no qual o mesmo possa efetuar tais Testes.
O processo de Integração Continua, e em particular Publicação Continua - Continuous Deploy - e Entrega Contínua - Continuous Delivery, são muito mais do que entregar produtos para os usuários de forma rápida. Quanto tempo seu time faz pequenas alterações de códigos antes de ir para produção? Quanto custa o processo de resolver problemas que ocorreram há muito tempo gerando grandes demandas de falha? Para que o CI possa resolver todos os nossos problemas, devemos não só programar como Integração Contínua como também devemos pensar como Integração Contínua.
Corrigir builds quebrados se torna prioridade absoluta e não devem deixar estagnar o processo. O processo de implementação precisa ser automatizado, com nenhum passo manual envolvido.
Uma das definições mais conhecidas de Integração Contínua foi dita por Martin Fowler que diz: “Integração Continua é uma prática dentro de desenvolvimento de software onde membros de um time integram seu trabalho freqüentemente, normalmente cada um executa no mínimo uma a várias integrações por dia. Cada integração é verificada por um build automatizado (incluindo os testes) para identificar erros de integração o mais rápido possível. Muitas equipes vêem nesta forma de trabalho uma redução significativa nos problemas de integração e permitem uma equpe desenvolver software de uma forma coesa mais rapidamente.”
Resumindo, um processo automatizado que constrói, testa, analisa e implementa uma aplicação para ajudar e garantir que o processo funcione corretamente seguindo as melhores práticas e as tornem entregáveis. Este processo é executado em cada mudança de código fonte e permite resposta imediata para a equipe de desenvolvimento. Diante disto, temos um termo que precisamos compreender que é o Build. O Build, nada mais é do que o processo de compilar, analisar e entregar o assembly pronto para implementação. Exemplificando, pode ser que, desenvolvamos uma camada da aplicação e commitemos seu código dentro do Controle de Versão, logo, o Sistema de Integração Continua, quando for executar a sua tarefa rotineira, irá compilar, testar e posteriormente gerar o assembly no local já pronto.

Processos de Desenvolvimento para Integração Contínua

Seu processo de desenvolvimento é ágil? Em sua equipe é utilizada Extremme Programming - XP -, Scrum ou algum outro? Sua companhia é profundamente enraizada em usar o método Cascata? Seu processo está em algum lugar entre Ágil e Cascata? A resposta a estas perguntas não importa, porque todas as equipes sem exceção devem seguir um processo parecido com o que é mostrado a seguir.

1.      Baixa o código fonte, necessário para a programação, de seu SCM.
2.      Faz alterações neste código.
3.       No Visual Studio, clica em Build e espera que o código compile com sucesso.
4.       Volta ao passo dois, caso o Visual Studio identifique erros.
5.       Executa os testes unitários, e espera que tudo fique verde, ou seja, que passe em todos.
6.       Volta ao passo dois, caso o teste unitário falhe, neste caso, o desenvolvedor vê um alerta vermelho e pode ver mais de um.
7.       Refatora o código tornando-o mais compreensível e então volta ao passo cinco.
8.      Efetua o envio do seu código alterado para o SCM, este trabalho é chamado de commit.

Vendo o processo demonstrado no parágrafo anterior e quando começamos a utilizar o CI, notamos que seguimos o mesmo processo. Porém, para o CI, o processo ainda vai mais além, posto que ele faça todos estes passos e ainda continua após o commit do código por parte do desenvolvedor, como veremos a continuação dos passos mais adiante.

9.      O Servidor de CI observa as alterações no SCM.Quando encontra qualquer nova alteração, ele efetua um download da última versão do código contendo o último commit.
10.   O Servidor de CI efetua o build do código.
11.  O Servidor de CI executa o teste unitário.
12.   O Servidor de CI envia os resultados do builds e o resultado dos testes para um sistema de comunicação, normalmente e-mail, mas também pode ser em SMS, Mensageiro instantâneo ou outro, para informar aos membros do time o estado do build.

Tipos de Construção para a Integração Contínua

Os passos da Integração Contínua que descrevemos anteriormente nos trazem o entendimento de  que cada vez que um desenvolvedor altera e sobe o código, um build é acionado, porém, em verdade, este é o último objetivo e a razão pela qual este processo é chamado de Integração Contínua.
Uma forma de começar a configurar o seu Servidor de CI é obter as últimas alterações de seu código e efetuar o build.
No próximo passo, adicione os testes unitários. E então, execute esta operação diariamente, que chamaremos de Build diário.
Mas, veremos que, em um determinado momento, um build diário inclui outras coisas que não nos atendem quando fazemos um build incremental. Quando temos builds executados todos os dias, podemos adicionar a este processo mais dois ou três builds que apenas constroem e testam o software. Não demorará e estaremos construindo e adicionando compilações diferentes para fazer coisas diferentes o tempo todo. Existem tipos de builds que dependem do ambiente e da natureza das aplicações, alguns dos builds mais comuns são mostrados na tabela 1.

Tipo de Build
Descrição
Contínuo ou Incremental
É executado quando o código é commitado no SCM. Executa uma compilação rápida e um ou outro Teste Unitário.
Diário ou Noturno (Daily ou Nightly Builds)
Executa uma compilação e um gama maior de testes unitários e em alguns casos pode executar testes adicionais como testes de aceitação e teste de Interface de usuário.
Semanal
Executa a compilação, testes de unidade completos e testes adicionais como testes de aceitação, testes de fumaça e afins.
QA
Cria um build apenas para verificações do pessoal do Setor de Qualidade contendo as métricas para tal.
Staging ou Pré-Produção
Consiste em ser um servidor que age como uma réplica perfeita do ambiente de produção, também pode ser chamado de pré-produção em alguns lugares. Nesta categoria, o build é executado e retornando sucesso, deixa os assemblies disponíveis para testes em pré-produção.
Release
Cria um conjunto de instalação e então efetua os testes de instalação e todos os outros processos necessários ao funcionamento do sistema em Produção e retorna o feedback.
Tabela 1. Tipos de Build

O build mais importante, e é justamente o que nos dá o resultado mais rápido, é o build contínuo ou incremental. Tal build é automaticamente chamado quando o CI identifica uma alteração no código fonte commitado no SCM. Como este build é executado muitas vezes durante o dia e um build pode ser executado logo após o término de outro. Este pode ser executado a cada cinco ou dez minutos.
Ocupando o segundo lugar em frequência, por ser executado em um período mais espaçado, é o build diário, também chamado de build noturno. Tal antítese pode ter gerado alguma confusão, posto que a pergunta que se faz é: ele é noturno ou diário? A resposta é: não importa, posto que ele seja executado uma vez por dia e preferencialmente quando não se tem quase nenhuma atividade na infra-estrutura, pode ser um horário durante o dia em que todos devem ter ido almoçar ou durante a madrugada, por isso a dualidade, que pode ser conflitante em alguns casos, de conceitos. Tal tipo de build é agendado para que execute todo um gama de testes unitários em todo o código, sem exceção, por isso que é muito importante ter um seu Projeto uma estratégia de testes para os módulos bem definida para que estes builds nos devolvam a informação verossímil e necessária, também verificamos a qualidade do software utilizando Cobertura de Códigos e Métricas de software.
Outro tipo de build é o Build Semanal, que executa automaticamente e de forma usual sempre aos finais de semana. Uma vez por semana é o suficientes para medirmos a qualidade de nosso código e executar Testes adicionais com ferramentas para testes de fumaça como Selenium, FitNesse e NUnitForms. Também, podemos criar a documentação de nosso código utilizando SandCastle e fazer a Integração Contínua de nossa base de dados.
Para um controle maior da data de liberação das novas versões do seu sistema, além do build semanal, também seria recomendado um build de release.
O propósito do build do release é criar um conjunto de instalação e executá-lo. Este build normalmente é executado manualmente. Mas, após o build ser iniciado, todos os outros passos são executados automaticamente. No build de release, o CI compila todo o código Fonte, executa todos os testes criados, incrementa o número de versão e etc. Então é criado o conjunto de artefatos para a implementação do mesmo e posterior teste desta implementação. Podem existir outros tipos de builds de acordo com as necessidades.
  
CI em alguns passos para a sua organização

A Integração Contínua não é a solução para todos os nossos problemas como já foi dito anteriormente. Claro que introduzir a CI dentro da empresa nos mostra um caminho a percorrer através de ciclos distintos. Cada um destes ciclos envolve melhorias que são incrementais entre si para todo o corpo técnico, sejam eles servidores ou profissionais da equipe de desenvolvimento bem como melhorias na cultura e estrutura de trabalho. Vamos mostrar nos parágrafos seguintes, um pouco de cada ciclo organizado do mais elementar ao mais maduro em uma empresa fictícia, a Imbróglios no Código LTDA, que estava à beira da falência, mas que acabou se organizando e utilizou a CI como o ponto inicial de sua alavancagem e crescimento Financeiro, dos 10 Analistas Iniciais dentro do Estado do Rio de Janeiro, a Imbróglios hoje em dia emprega mais de 3.000 profissionais de TI nos cinco continentes, muitos dos Analistas da época tornaram-se gestores. A Imbróglios no Código estava à beira da falênca, mas não por erros apenas de seus profissionais de desenvolvimento, mas por não disporem de uma infraestrutura competitiva. Enfim, a empresa havia parado no tempo e começou a ouvir as opiniões de seus colaboradores, em reuniões diárias, como último recurso para evitar a completa bancarrota, nestas  reuniões a palavra Integração Contínua e outros termos sobre o mesmo assunto foram mencionadas e também os gestores identificaram que membros da equipe já detinham tal conhecimento oriundo de experiências anteriores, mas que no passado a gerência não os permitia implementar tais idéias porque "não havia espaço no cronograma e o tempo era curto". Apesar de uma parte da equipe declarar oposição diante desta medida, que veremos como tal resistência foi combalida, a Diretoria comprou a idéia e deu um prazo de 5 meses a contar daquele momento e transcrevemos abaixo os trechos mais importantes da consultoria na qual este autor tomou parte e participou do processo para que o leitor acompanhe ciclo por ciclo como a Integração Contínua pode mudar a filosofia de trabalho de uma organização.
Primeiro Ciclo. Não existe Servidor de Build. Inicialmente, a equipe ainda não dispõe de nenhum tipo de Servidor Central de builds. O Software é compilado e construído manualmente na máquina do desenvolvedor, mesmo que se use um Script NAnt ou similar. O Código Fonte dos Projetos é armazenado em servidores centralizados, mas desenvolvedores nem sempre commitam suas alterações neste Servidor. Antes que uma versão estável ser liberada, um desenvolvedor executa a integração, das alterações no código fonte da aplicação, de forma manual, este processo gera um grande prejuízo no que tange a ultima parte: integração manual de código.
Segundo Ciclo. Builds Noturnos ou Diários (Nightly ou Daily). O time agora dispõe de um servidor para builds e builds automatizados são agendados em um período regular, sendo tipicamente à noite ou durante o dia quando o fluxo de trabalho é interrompido por algum período - horario de almoço coletivo, reunião diária entre equipes ou afins, algo que cause queda de utilização do link. Estes builds apenas compilam os códigos, ainda não existem Testes Unitários sendo executados. Testes Unitários quando existem, não são parte integral ou obrigatória do processo de build. Desenvolvedores commitam suas alterações de Código Fonte regularmente, normalmente, no final do dia. Se um membro da equipe de desenvolvimento efetua um commit de seus códigos e este conflita com o trabalho de outro membro da equipe, o servidor de builds alerta toda a equipe via e-mail na manhã seguinte. Porém, faz-se mister que o time ainda utilize o servidor de builds com o único propósito de informar as quebras e nada mais, logo a equipe acaba se sentindo desobrigada à corrigir toda a compilação interrompida para corrigir apenas aquele build em sua estação de trabalho, e o build pode ficar quebrado no servidor de por um tempo maior.
Terceiro Ciclo. Builds Noturnos e Automação de Testes Básicos. O time agora já está começando a tirar proveito da Integração Contínua com Testes automatizados mais seriamente. O servidor de build está configurado para dar início a um novo build assim que um novo código é commitado para o SCM e aos membros do time é permitida a livre visualização da alteração do código gerou a execução do Build e qual o impacto desta mudança. Além disso, o script que executa o build compila a aplicação e executa um conjunto de testes unitários ou testes de integração automatizados. Com relação ao envio de mensagens à equipe, o servidor de builds também envia um alerta aos membros do time sobre problemas na integração utilizando não só o e-mail, mas como outras formas mais proativas como mensageiros instantâneos. Builds que ficam quebrados agora são corrigidos mais rapidamente.
Quarto Ciclo. Tem início a Revolução das Métricas. Agora a equipe dispõe de verificação da Qualidade de Código automatizada e validação de métricas quanto à cobertura do código junto às melhores práticas, auxiliam muito na verificação para a eficiência dos nossos testes. Existe um build que incide apenas sobre a verificação da qualidade do código, ou seja, em um processo que é executado de forma distinta dos outros builds mostrados anteriormente, este ocorre sempre, de forma separada, sobre a versão mais estável que está sendo executada, também gera uma documentação sobre a API utilizada para a criação da aplicação, facilitando assim a organização do código e escalabilidade da infraestrutura da aplicação ao longo do tempo o que facilita a chegada de novos membros à equipe e diminui o tempo de treinamento do novo recurso. Este tipo de implementação da CI ajuda a equipe a manter a qualidade do código sempre em alto nível, informando ao time quais métricas/práticas de testes estão sendo eficientes e úteis ao processo. O time também dispõe de um Painel de Acompanhamento de Builds, que consiste em mostrar os resultados de todo o Projeto em um Monitor na Sala ou no corredor da empresa de forma que todos tenham visibilidade de todos os processos de CI que estejam sendo executados e os status destes.
Quinto Ciclo. Testando de forma mais aprofundada e automatizada. Os benefícios da Integração Congtínua são intimamente relacionados à práticas de testes bem consolidadas dentro da equipe. Agora, práticas como Desenvolvimento Orientado a Testes, TDD, são largamente utilizados resultando em um crescimento na confiança dos resultados dos builds automatizados. A aplicação não é mais simplesmente compilada e testada, mas se o teste tem sucesso, este é automaticamente implementado para um servidor de aplicação para testes de outros tipos tais como testes de Aceitação e Testes de Desempenho e chegando a este ponto, já podemos começar o 6º e penúltimo ciclo, o dos Testes de Aceitação e Implementação que levará a empresa à filosofia da Entrega Contínua.
Sexto Ciclo. Testes automatizados de Aceitação e uma implementação melhor elaborada. O Desenvolvimento Orientado à Testes de Aceitação é praticado, guiando esforços de desenvolvimento e providenciando sempre relatórios de alto nível do estado atual do Projeto. Estes testes automatizados utilizam ferramentas para Desenvolvimento Orientado a Comportamentos, BDD, que agem como agentes para comunicação e documentação assim como as ferramentas de testes que publicam relatórios sobre os resultados de testes nos termos de negócio que profissionais que não sejam de desenvolvimento possam entender. Uma vez que testes de alto nível sejam automatizados dentro do projeto o mais cedo possível no processo de desenvolvimento, eles também dão a idéia de que melhorias foram implementadas e o quanto falta para a entrega da iteração ou do Projeto como um todo. A aplicação é automaticamente implementada no ambiente especifico para testes junto ao pessoal da Qualidade, ou QA, tão logo as alterações sejam commitada no SCM ou em uma base de build noturno. Uma versão estável do software projetado poder ser implementada em ambiente controlado, como pré-produção por exemplo, utilizando um build executado manualmente, caso a Equipe de Testes julgar estável. A equipe de desenvolvimento também será capaz de utilizar o servidor de build para proteger a versão estável gerando um rollback para uma versão anterior, se algum erro brusco e crítico ocorrer.
Sétimo Ciclo. Entrega Contínua. Existe um confiança colocada nos testes automatizados de Unidade, de Integração e de Aceitação de tal forma que as equipes podem aplicar as técnicas de implementação automatizada no Ciclo 6, porém, caso tudo corra bem, podem permitir que o CI implemente-as diretamente em produção em caso positivo dos builds. É este tipo de procedimento que configura a Entrega Continua e pelo que pudemos ver no decorrer deste processo,a única intervenção humana neste processo foi executada no ciclo 6 para testes de implementação.
Será dentro destes ciclos que nossa série de artigo irá funcionar, utilizaremos estes 7 ciclos de forma a mostrar de forma prática para o leitor como que o CI vai evoluindo dentro da Organização e como o nosso script de build vai sendo incrementado durante a implementação das melhorias. Porém, diante de toda esta revolução como foi visto anteriormente, grandes objeções surgem por estarmos lidando com o fator humano que não é feito à mudanças. Podemos vencer os mais resistentes com simples respostas para complexas perguntas e será o que veremos à seguir.

Lidando com a resistência às mudanças
Com todos estes builds acontecendo e membros da equipe tendo que modificar a sua rotina e efetuar atualizações em seus códigos, com os códigos mais atuais para se manterem atualizados motivados por um servidor de SCM, de forma freqüente, ou seja, quase que diariamente, podemos encontrar certas objeções dos membros do time e as mais comuns veremos a seguir.
CI aumenta a manutenção. Algum membro terá de manter o Sistema de CI. Tal procedimento fará com que este membro saia de seu escopo de ser apenas um desenvolvedor. No início, existirá um tempo maior que gerará um excesso de trabalho ao membro da equipe, porém, o time terá uma grande economia de tempo posto que o grande gargalo conhecido, que era o da Integração manual, não irá ocorrer e tornará o teste da aplicação mais simples. Muitas equipes informam, e isso é facilmente encontrado na Grande Rede, que após o processo de CI ser implantado, as rotinas de manutenção demoram menos que uma hora por semana na média.
Estas mudanças são rápidas demais e são muitas. É difícil se adaptar a uma nova forma de se fazer algo. Não implementar tudo de uma só vez. Começar com um build simples executado uma vez ao dia e então adicionar um teste unitário. Após o time se sentir mais confortável e se acostumar com esta rotina podem adicionar um ou mais builds por dia ou começar a executar uma Análise de Código. Por implementar o processo em pequenos passos e mostrar que estes pequenos passos nos retornam grandes resultados - principalmente em tempo e facilidade, teremos mais aceitação dentro deste novo processo.
CI implica em uma custo adicional de hardware e de software. Comece com um PC antigo como seu servidor de CI se conseguir. Eventualmente, vamos precisar melhorar o hardware para que possamos executar builds de forma mais veloz (devemos nos lembrar de que um build de integração, demora no mínimo, 5 minutos), mas para builds executados de duas à três vezes ao dia, máquinas antigas também vão nos atender. Se as ferramentas que informarmos nesta série forem utilizadas como recomendamos, o seu custo com software será mínimo.
Desenvolvedores devem compilar e testar. Não estamos tirando estas responsabilidades dos desenvolvedores. Estamos apenas movendo boa parte do trabalho mais demorado e oneroso para um Sistema automatizado. Tal medida fará com que os membros da equipe possam produzir mais e resolver melhor os problemas de Regras de Negócios que existam na aplicação, logo esta medida fará com que os desenvolvedores fiquem mais produtivos aonde importa: Escrever e identificar erros no código.
O Projeto é longo demais ou está adiantado demais para que adicionemos o CI. Embora seja muito melhor e mais fácil se colocar um projeto na CI desde o seu início, a verdade é que, muito do trabalho que é feito é justamente dentro de manutenção dos nossos Projetos já existentes. Um projeto que já exista pode não ter Testes Unitários, mas podemos utilizar um SCM e precisar fazer builds destes. Podemos nos beneficiar da CI não importando o tempo e o tamanho do Projeto.
Se a CI for colocada em seu devido lugar, muitos dos problemas mais conhecidos dentro de um Projeto de Software: do desenvolvimento à entrega e manutenção devem ocorrer. Mais adiante, vemos muitas razões para que se utilize o CI em seu processo de desenvolvimento.
Riscos Reduzidos. Implementando bons processos de CI, criaremos software com uma performance muito melhor que a habitual porque já teremos feito os testes unitários e testes de integração de código muito mais cedo dentro do processo, então aumentamos as chances de corrigir erros também muito cedo. Falaremos sobre Riscos na próxima e derradeira seção desta primeira parte.
Produto implementado de forma simples. Se automatizarmos o processo de instalação. Nós saberemos sobre o comportamento de sua instalação antes de receber um feedback de problemas do cliente.
Visibilidade de Projeto. O mecanismo de feedback permite aos membros da equipe saber sobre os resultados do build e onde estão os problemas. Os problemas podem ser corrigido o quanto antes e esta abordagem reduz custos e o tempo gasto corrigindo problemas.
Não permita que as objeções dos membros nos obrigue a recuar ou resistir. A resistência inicial irá diminuir gradualmente quando a equipe começar a trabalhar diretamente com o Sistema de CI. Uma Terapeuta Familiar muito conhecido em outros países chamada Virginia Satir criou o Modelo de Mudanças Satir que se refere sobre como as famílias lidam com a mudança. E transportando algumas diretrizes para lidar com a equipe, temos a seguir algumas boas recomendações. E este processo de mudança envolve cinco passos.
Passo 1. Status Quo Tardio. Todos estão trabalhando normalmente no processo atual e todos sabem como ele funciona.
Passo 2. Resistência. Um novo elemento é introduzido no seio da equipe. As pessoas são sempre hesitantes para mudar a sua rotina. Se o status quo funciona muito bem, por que modificá-lo?
Passo 3. Caos. O novo elemento introduzido é adotado. Não há uma forma normal de fazer novas coisas. Rotinas diárias são despedaçadas.
Passo 4. Integração. Pessoas se ajustam lentamente ao novo modo de se fazer coisas. Fica mais fácil fazer o trabalho de convencimento se utilizar esta abordagem. E começam a utilizá-lo, mas de forma gradual.
Passo 5. Novo status quo. O novo elemento já está totalmente integrado ao Sistema. As pessoas agora o vêem como Normal e voltamos ao passo 1.
Quase todos os times acabam adotando novas metodologias de uma hora para outra. Este processo por soar familiar. Assim como lutamos contra a resistência da equipe, sejamos persistentes em implementar as mudanças. Os membros do time em breve vão aceitá-las. Alguns membros vão adotar o CI mais rápido que outros alguns podem precisar de uma dose maior de convencimento. Talvez seja necessário mostrar a eles como o CI reduz os riscos e os custos e benefícios dentro do processo de desenvolvimento.

Custo Benefício da Integração Contínua
Seu cliente não gosta de riscos. Seu gerente não gosta de riscos. Seu Gerente de Projetos precisa ter planos para mitigar os riscos. No fim, não vamos gostar de riscos. CI é sempre apontado como uma redução nos riscos. Talvez o maior risco dentro do desenvolvimento de software é o não cumprimento de prazos, em outras palavras o projeto sendo entregue mais tarde do que o acordado e contratado. Por causa do mecanismo de feedback no processo de CI, os membros do time sempre vão saber do estado do build atual, que nos auxilia a saber se o projeto está dentro dos prazos.
Veremos o mecanismo de feedback mais adiante em nossa série de artigos.
O outro grande risco é o risco de defeito, os chamados bugs. Como já mostramos anteriormente, que quanto mais tardia é a política de defeitos aplicada a um projeto, maior será o custo para corrigi-los. Algumas estimativas sugerem que o custo para a correção de um defeito gira em torno de R$3.500,00 em média para corrigir um simples defeito de software em aplicações internas. Anos atrás, uma companhia de antivírus bem conhecida gerou defeito dentro de um de seus pacotes de atualização. Este pequeno defeito fez com que os clientes perdessem confiança naquele antivirus e forçaram a empresa a reduzir seus rendimentos trimestrais e previsões orçamentárias de receita em US$8.000.000,00. Não gostaríamos de ver a nossa empresa passar por algo parecido.
Uma das vantagens da CI neste ponto é que os defeitos são corrigidos tão logo eles são identificados. Integrando e testando o software a cada build, podemos identificar e corrigir defeitos no processo. Discutiremos Testes Unitários mais adiante em nossa série de Artigos.
Sempre fizemos algumas perguntas para saber o andamento de nosso projeto como: consideramos quantos caminhos diferentes podem existir em nosso código fonte? testamos a combinação de cada if/else? Quantos casos de declarações switch foram testadas? respondemos estas perguntas implementando a Cobertura de Código.
Cobertura de Código é a metodologia que verifica quais caminhos serão testados e quais não serão. Uma grande solução quando o assunto é cobertura de código é que podemos automatizá-la em nosso processo de CI. É humanamente impossível de serem testadas todas as combinações de cobertura existentes, mas quanto mais for testado, menos problemas serão descobertos pelo seu cliente.
Outro risco conhecido são as atualizações em Bancos de Dados. Nunca foi fácil adicionar campos para uma tabela ou novas tabelas em um Banco de Dados.
Com Integração Contínua em Banco de Dados, teremos ciência se as mudanças implementadas trabalham corretamente e sem perda de dados. Demonstraremos Integração Contínua em Bancos de Dados mais adiante nesta série.
Desenvolvedores odeiam padrões de codificação e arquiteturais, mas têm seu propósito útil: permitem que a aplicação siga as melhores práticas, fazem com que a aplicação funcione melhor e fica mais fácil de manter. Revisões de Código identificam muitos problemas; mas, como Revisão de Código é um processo manual, algumas coisas podem se perder. Então, por que não automatizar a verificação da padronização em seu processo de CI? cobriremos também a Revisão de Código mais adiante nesta série.
Comentários são colocados raramente no código e a documentação quase não existe. Muitos dizem que se formos ágeis, não precisamos de documentação, mas isso não é verdade. O Manifesto Ágil diz que o trabalho é mais valorizado que a documentação. Mas, a documentação é ainda necessária, especialmente se estivermos criando assemblies a serem utilizados por outras equipes ou outras pessoas em forma de APIs. Esta é outra oportunidade para automatizar seu processo com processos de CI. Cobriremos esta parte também nesta série de artigos mais adiante.
Como saberemos que o processo de instalação/implementação funcionou corretamente? Existem poucas coisas que frustram mais usuários do que não conseguirem instalar ou implementar uma aplicação. É fácil ver problemas escondidos no Projeto que sem um sistema de CI só seria identificado muito depois do processo de desenvolvimento, quando os problemas já se tornaram bem mais difíceis e caros para se corrigir. Agora que já sabemos o que a Integração Continua é e como ela pode melhorar nossos processo de desenvolvimento nas próximas partes veremos o processo de CI ser implementado gradualmente seguindo os ciclos informados nesta primeira parte.
Nesta primeira etapa de nossa série sobre a Integração Contínua, vimos os grandes problemas que são encontrados em projetos, organizações e equipes de forma que preparamos o leitor para os desafios que serão encontrados nesta busca pela excelência em seus projetos e tal excelência começa com o Sistema de Integração Contínua. O maior obstáculo para a implementação não está no Projeto em si, mas na resistência das equipes em implementá-lo dentro das organizações.
Assim que a resistência é combalida demonstrando no dia a dia como a CI é útil e viável, a implementação começa a mudar de forma lenta, mas drástica a forma como as organizações interagem dentro do Projeto de Software. Tendo mais agilidade, as equipes conseguem melhores resultados.