Metodologias Ágeis e DevOps: desenvolvendo software com qualidade, colaboração e eficiência

Ciclo de Vida do Software - 1.1 - Apresentação

Apresentando o instrutor e o curso

Olá! Meu nome é Lucas, sou instrutor na Alura e dou as boas-vindas a este curso.

Audiodescrição: Lucas é uma pessoa branca, usa óculos, tem barba e cabelo preto, e veste uma camisa cinza. Está nos estúdios da Alura.

Neste curso, vamos explorar abordagens que podemos utilizar para o desenvolvimento de software. Começaremos analisando o ciclo de vida do desenvolvimento de software. Vamos perceber que o software não começa apenas na etapa em que abrimos uma IDE no ambiente de desenvolvimento e escrevemos os códigos; ele começa muito antes disso.

Explorando o planejamento e as abordagens de desenvolvimento

Na etapa de planejamento, é feito o levantamento dos requisitos e a documentação das regras de negócio por pessoas que atuam mais fortemente junto aos stakeholders e clientes, ou seja, as partes interessadas no software e sistema que estamos desenvolvendo. A partir daí, nós, como pessoas desenvolvedoras, precisamos nos organizar em equipe para implementar de fato aqueles requisitos e construir essa aplicação.

E como fazemos isso? Podemos utilizar diferentes abordagens de desenvolvimento.

Discutindo modelos de desenvolvimento e o Manifesto Ágil

Vamos explorar os primórdios do mundo da tecnologia, começando com o modelo em cascata, que ainda pode ser utilizado em alguns projetos, e o modelo em espiral, até chegarmos ao surgimento, em 2001, do Manifesto Ágil. Este manifesto trouxe valores e princípios que representam um marco nas abordagens de desenvolvimento de software.

A partir do Manifesto Ágil, analisaremos como utilizar o framework de gerenciamento de projetos Scrum, e até mesmo em conjunto com outro método de organização chamado Kanban, que vem do Lean Software Development, originado no Lean Manufacturing, surgido no pós-guerra como sistema Toyota de produção. Vamos avaliar e explorar essas abordagens de desenvolvimento, seus principais fundamentos e boas práticas ao longo desta jornada.

Analisando culturas de desenvolvimento e a importância da documentação

Por fim, analisaremos o surgimento e a difusão de culturas, como a cultura de qualidade, a cultura DevOps, e o que é DevSecOps. Discutiremos como implantar a cultura DevOps dentro das empresas, o que é a cultura Ágil, seus principais valores e fundamentos, tanto do ponto de vista individual quanto no âmbito coletivo, como equipe. Destacaremos também a importância da documentação para manter e evoluir nossas aplicações.

Além dos vídeos, teremos atividades ao longo deste curso. Vamos iniciar nossa jornada pelo mundo das abordagens de desenvolvimento?

Ciclo de Vida do Software - 1.2 - Ciclo de vida de desenvolvimento

Introduzindo o ciclo de vida do desenvolvimento de software

Quando pensamos no desenvolvimento de software, talvez a primeira imagem que venha à nossa mente seja de uma pessoa sentada em frente ao computador, com o ambiente de desenvolvimento aberto, escrevendo várias linhas de código, realizando testes, analisando os resultados obtidos e refatorando, melhorando a solução até que ela fique funcional para ser entregue ao público-alvo, às pessoas usuárias. De fato, os estágios de implementação, teste e entrega são etapas muito importantes do ciclo de desenvolvimento, mas ele vai além disso, por isso falamos no ciclo de vida do desenvolvimento de software.

Esse ciclo começa desde etapas bem iniciais, quando planejamos o que vamos desenvolver, definindo os objetivos do projeto, do negócio, o escopo do projeto, até mesmo a fase em que definimos qual será a arquitetura e como vamos escalar essa solução caso haja uma demanda maior do que o esperado. Após a entrega no ambiente de produção, como deploy ou implantação dessa solução, passamos para os estágios de manutenção e evolução, nos quais observamos o feedback a partir da interação dessa solução com as pessoas usuárias e evoluímos para atender de maneira constante as demandas desse mercado cada vez mais dinâmico, o mercado da tecnologia.

Analisando o estágio de planejamento

Para compreendermos bem que tipo de abordagem podemos utilizar como um time de desenvolvimento para a construção dessa solução, é preciso entender cada um desses estágios do ciclo de vida de um software. Vamos começar analisando o estágio de planejamento. No planejamento, começamos definindo os objetivos do projeto e do negócio, avaliamos todos os riscos envolvidos, as dependências que teremos no processo de desenvolvimento, e definimos também alguns indicadores de sucesso. A partir disso, traçamos o escopo preliminar desse projeto.

Depois de definir os objetivos e fazer esse planejamento de alto nível, realizamos uma análise de requisitos, que é um estágio importante no qual definimos, por exemplo, as regras de negócio que nossa solução deverá atender, assim como os requisitos funcionais e não funcionais. Ou seja, todas as funcionalidades que nosso software deve possuir e também alguns aspectos não funcionais, como questões estéticas e de usabilidade, que são importantes no dia a dia das pessoas usuárias.

Mapeando processos e priorizando requisitos

A partir disso, fazemos um mapeamento de processos e precisamos estar em constante contato com as pessoas interessadas nesse projeto, ou partes interessadas, que chamamos de stakeholders, ou clientes desse negócio. A partir desse contato com os clientes, precisamos validar os requisitos e regras de negócio e também definir uma priorização. Muitas vezes, no desenvolvimento de software, temos que implementar múltiplas funcionalidades, mas para a entrega de uma versão funcional que atenda em grande parte as expectativas das pessoas usuárias, não implementamos todos os requisitos de regra de negócio na primeira versão. Por isso, é importante definir essa ordem de priorização que seguiremos no processo de desenvolvimento.

Concebendo a solução e definindo a arquitetura

Após a análise de requisitos, não começamos imediatamente a implementar o código. Primeiro, passamos para a fase de concepção da solução, na qual definimos a arquitetura e o design do sistema. Também realizamos a modelagem dos dados e dos fluxos de dados dentro do software. A partir disso, selecionamos as tecnologias que utilizaremos, como as linguagens de programação, o padrão de banco de dados, os frameworks que eventualmente usaremos, as APIs que precisaremos construir e os serviços externos que serão necessários.

Além disso, traçamos um plano de integração da nossa solução com soluções existentes e um plano de escalabilidade. Isso é importante porque, embora comecemos com um número específico de funcionalidades, pode ser que, no futuro, precisemos implementar novas funcionalidades e serviços. Portanto, é essencial pensar em uma solução escalável e de fácil manutenção.

Desenvolvendo o sistema e garantindo a qualidade

Somente após essa fase é que começamos a desenvolver o sistema, escrevendo as primeiras linhas de código. Durante esse processo, é crucial adotar boas práticas de versionamento e controle de código, especialmente porque trabalhamos em equipe e todos devem estar alinhados. Também aplicamos padrões de qualidade para desenvolver uma solução de alto nível e documentamos o que estamos construindo para facilitar a manutenção e atualização futuras.

Há um estágio que, embora não seja separado, faz parte do processo de implementação: o estágio de testes. Os testes são realizados para garantir a qualidade e segurança do que estamos construindo e para assegurar que a solução atende às regras de negócio e requisitos definidos a partir da análise de mercado e do contato com os stakeholders do projeto. Esses testes são cada vez mais automatizados, e por isso falamos sobre pipelines automatizados de integração e entrega contínua.

Validando e implantando a solução

Quando temos uma versão pronta do software para ser entregue no ambiente de produção, realizamos testes em um ambiente controlado, chamado de staging, para validação. Isso nos proporciona um feedback contínuo da equipe, permitindo ajustes e refatorações quando necessário. É importante que o ciclo de desenvolvimento e testes ocorra de maneira iterativa, e não sequencial. Muitas vezes, adotamos práticas de desenvolvimento de testes antes do código, conhecidas como TDD, que serão avaliadas mais adiante no curso.

Após garantir que tudo está funcionando conforme o esperado, fazemos a entrega da solução e passamos para a implantação ou deploy. Geralmente, trabalhamos com entregas automatizadas, adotamos estratégias de release e realizamos monitoramento pós-deploy para verificar se tudo está correto no ambiente de produção. Também temos planos de rollback, ou seja, planos para retornar à versão anterior da solução caso algo não funcione bem.

Mantendo e evoluindo o software

Por fim, o ciclo de vida do software não termina, mas muitas vezes inicia novas versões, atualizações e ajustes. Nos estágios de manutenção e evolução, adotamos boas práticas de ajustes contínuos, atualizações e refatorações. Monitoramos permanentemente os dados gerados e os feedbacks das pessoas usuárias ao interagirem com a solução, planejando a evolução do software como um organismo vivo que precisa ser ajustado e melhorado para atender às expectativas do mercado.

Explorando abordagens de desenvolvimento

Após analisar todo esse ciclo de vida do desenvolvimento de software, surge a questão: como desenvolvemos um software? Nos primórdios, adotávamos abordagens sequenciais e lineares, mas percebemos que essas abordagens não traziam bons resultados em muitos projetos. A evolução dessas abordagens de desenvolvimento de software será analisada no próximo vídeo.

Ciclo de Vida do Software - 1.3 - Evolução das abordagens de desenvolvimento

Analisando a evolução das abordagens de desenvolvimento de software

Agora que conhecemos mais sobre os diferentes estágios do ciclo de vida do desenvolvimento de um software, é hora de analisarmos a evolução das diferentes abordagens utilizadas para o processo de desenvolvimento, para a organização das diferentes etapas e até mesmo dos times de tecnologia das empresas. Tudo começou nos anos 70, quando tínhamos os primeiros computadores baseados na eletrônica, que são a base da computação ainda hoje. Nesse momento inicial, utilizávamos o modelo conhecido como Waterfall, ou modelo de desenvolvimento em cascata. Trata-se de um framework, uma abordagem de desenvolvimento de projetos de maneira geral.

Posteriormente, surgiu o modelo mais iterativo, baseado em uma evolução incremental do projeto, conhecido como espiral. Nos anos 90, a indústria do software ganhou cada vez mais importância no âmbito econômico e mundial. Nesse contexto, houve a difusão dos computadores nos ambientes corporativos, na indústria e até mesmo nas residências, no final dos anos 90. Com isso, surgiu um conjunto de boas práticas relacionadas à engenharia e arquitetura do software, já pensando na escalabilidade, pois as coisas estavam evoluindo e mudando, e precisávamos atualizar, implementar novas funcionalidades e ajustar.

Explorando o Rational Unified Process e o Manifesto Ágil

Dessa forma, surgiu um framework de engenharia de software proprietário de uma empresa conhecida como Rational Software, chamado Rational Unified Process, que é um processo racional unificado, em uma tradução livre. Anos mais tarde, essa empresa foi incorporada pela IBM, tornando esse framework proprietário da própria IBM.

Em 2001, tivemos outro marco na evolução das abordagens utilizadas no desenvolvimento do software com a publicação do Manifesto Ágil. Esse manifesto trouxe valores e princípios importantes que guiaram a construção e consolidação de algumas abordagens técnicas e métodos que já existiam ou estavam em estágio embrionário nesse momento. Até que, em 2009, ocorreu a consolidação e difusão de uma cultura de integração dos diferentes grupos que compõem o setor de tecnologia de uma empresa, com a abordagem conhecida como DevOps. Trata-se de uma soma dos termos desenvolvimento e operações, referindo-se aos dois times que atuam fortemente tanto na construção quanto na operação dos sistemas que utilizamos no dia a dia. O CI/CD, a integração e a entrega contínua, tornou-se uma boa prática para a integração desses diferentes times.

Avaliando o modelo Waterfall

Vamos começar avaliando as primeiras abordagens que surgiram nesse processo evolutivo do ciclo de vida do desenvolvimento do software. Como primeiro modelo, temos o modelo Waterfall, ou cascata. Em que consiste? Basicamente, é uma abordagem linear e sequencial, ou seja, uma etapa após a outra. Isso consiste em implementar um código, e, após a implementação, avançar para o próximo estágio. Qual é o próximo estágio? Teste. Agora realizamos todos os testes. E se algo der errado? Precisaríamos voltar para a etapa de implementação para fazer as correções, e então seguir para uma etapa seguinte de correção.

Observe que há uma certa não linearidade no desenvolvimento do software. Muitas vezes, precisamos atuar e agir de maneira iterativa, envolvendo a colaboração de diferentes pessoas. Pessoas mais especialistas em testes, outras mais especialistas em arquitetura, boas práticas e design de código. Nesse modelo inicial, havia um foco muito forte em planejamento. Ou seja, estabeleciam-se as diretrizes do projeto e o objetivo, que deveriam ser seguidos de forma rígida ao longo de todo o desenvolvimento. Havia também um foco muito grande em documentação. Muitas vezes, a principal entrega das etapas eram documentos e relatórios do que foi realizado em uma semana ou em um mês pelo time de tecnologia. No entanto, isso muitas vezes podia funcionar ou não. No caso do software, isso era um entrave ao sucesso de muitos projetos.

Introduzindo o modelo espiral

Com isso, uma característica desse modelo é a baixa adaptabilidade ou flexibilidade para mudanças. Quando lidamos com um mercado de tecnologia muito dinâmico, frequentemente enfrentamos mudanças nos requisitos e regras de negócio. Portanto, essa resistência às mudanças acabou sendo um entrave para a ampla adoção desse modelo em projetos no setor de tecnologia. Assim, surgiu o modelo de desenvolvimento em espiral.

Ao invés de termos etapas sequenciais, organizamos nossa equipe de trabalho em ciclos, em períodos de tempo menores. Dentro desse período menor, devemos ter uma entrega significativa, como um protótipo ou uma versão funcional do software ou sistema em que estamos trabalhando. Isso inclui um incremento de funcionalidade, uma correção de bug, ou algo nesse sentido. Com isso, temos um processo de validação progressiva do sistema que está sendo construído por uma equipe, através de um projeto. Essa validação progressiva envolve também uma proximidade grande com os stakeholders desse projeto, para discussão e reavaliação dos requisitos e das regras de negócio, que podem mudar ao longo do tempo. Isso não ocorre apenas quando o sistema está em produção, mas também durante a implementação, pois as mudanças ocorrem frequentemente. Por isso, é importante estarmos sempre conectados com as diferentes partes interessadas no projeto de software que estamos construindo.

Detalhando o ciclo iterativo do modelo espiral

Nesse modelo em espiral, temos diferentes estágios dentro desse ciclo iterativo. Começamos com o planejamento, fazemos uma análise desse planejamento e de tudo aquilo que será implementado. Em seguida, passamos para a parte do design, onde concebemos como vamos implementar, implementamos e avaliamos os resultados daquele ciclo, sempre pensando na melhoria contínua. Os bons resultados e boas práticas de um ciclo podem ser aplicados nos próximos ciclos.

Antes do surgimento da consolidação da agilidade como uma abordagem no mundo do software, com o Manifesto Ágil em 2001, nos anos 90, houve o surgimento e a disseminação de um conjunto de boas práticas de engenharia de software, com foco em arquitetura. Isso já considerava aplicações que começam a crescer, que precisam ser atualizadas e refatoradas, e a arquitetura ganhava relevância no ciclo de desenvolvimento do software. Dentro desse framework de engenharia de software, desenvolvido pela empresa Rational Software, conhecido como Rational Unified Process, também utilizamos a modelagem dos sistemas com linguagens gráficas.

Explorando a modelagem e a programação orientada a objetos

A modelagem consiste em desenhar o sistema com alto nível de abstração, utilizando uma linguagem visual e textual mais próxima do nosso dia a dia, como a linguagem natural que estamos utilizando no curso. Isso permite que diferentes agentes e pessoas atuando no projeto se comuniquem de maneira fluida e efetiva em relação às funcionalidades a serem implementadas e aos pontos de melhoria, garantindo uma visão geral do projeto e de seu desenvolvimento. Surge, então, uma linguagem gráfica muito utilizada no mundo do software, chamada UML (Unified Modeling Language), que é uma linguagem unificada de modelagem de sistemas de software. Com essa linguagem, podemos representar tanto a estrutura do sistema e seus principais componentes, quanto os casos de uso e todo o comportamento, através de diagramas de atividade, diagramas de sequência e diagramas de casos de uso.

Dentro do escopo desse framework, também utilizamos a programação orientada a objetos, que demanda um pouco dessa modelagem para facilitar o entendimento de todos na equipe. Mantemos essa abordagem de ciclos iterativos com foco na evolução incremental do que está sendo construído pelo projeto e pela equipe de tecnologia.

Refletindo sobre a necessidade de agilidade no desenvolvimento de software

No início da indústria do software, na evolução dos anos 70 aos 90, percebemos que escopos fixos de projeto levavam a uma baixa adaptabilidade, o que não era positivo no contexto do software. Vimos também que uma entrega tardia dificultava a obtenção de feedback e o alinhamento do projeto de sistema com as expectativas das partes interessadas, sejam clientes ou stakeholders. Além disso, a flexibilidade limitada impedia adaptações e mudanças durante o curso do projeto. Com isso, o escopo fixo, a entrega apenas no final do projeto, utilizando uma abordagem linear e sequencial, e a baixa flexibilidade levaram à constatação de que faltava agilidade nesses projetos. Faltava agilidade na construção das soluções de software. É nesse contexto que surge o manifesto ágil, que vamos analisar no próximo vídeo.

Sobre o curso Metodologias Ágeis e DevOps: desenvolvendo software com qualidade, colaboração e eficiência

O curso Metodologias Ágeis e DevOps: desenvolvendo software com qualidade, colaboração e eficiência possui 125 minutos de vídeos, em um total de 42 atividades. Gostou? Conheça nossos outros cursos de Computação em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• capitulo