🔄 CAPÍTULO 02: MODELOS DE PROCESSO DE SOFTWARE

🎯 1. Objetivos de Aprendizagem & Competências

Estimativa de Dedicação: 2 horas de estudo autoguiado.
Ao final deste capítulo, você será capaz de:

• 🔹 Compreender as características, forças e limitações dos modelos Cascata, Prototipação, Espiral e Incremental.
• 🔹 Avaliar e selecionar o modelo de ciclo de vida ideal com base na volatilidade de requisitos, criticidade de segurança e prazos.
• 🔹 Analisar o impacto da gestão de riscos e feedback contínuo no custo de alteração de software.
• 🔹 Implementar um sistema de máquina de estados em Python 3.11+ para rastrear o ciclo de vida de transição de fases.

🏢 2. Cenário Corporativo & Estudo de Caso (TecProExpress)

Na TecProExpress, a diretoria de TI está iniciando dois novos projetos simultâneos:

1. Módulo de Telemetria e Frenagem Crítica: Integrado diretamente ao computador de bordo da frota pesada (risco de vida em caso de falha).
2. App de Chat do Motorista com IA: Ferramenta experimental para interação em tempo real com o suporte (requisitos muito voláteis).

O Desafio: A equipe técnica não pode aplicar a mesma estratégia de processo para ambos os produtos. Você deve estruturar a governança de processos, aplicando o modelo preditivo formal para o módulo crítico e o modelo incremental adaptativo para o app experimental.

🧠 3. Fundamentação Teórica & Modelos Visuais

3.1. Panorama dos Modelos de Ciclo de Vida

Um modelo de processo de software prescreve a ordem das atividades, os critérios de entrada/saída de cada fase e as estratégias de validação com os clientes.

flowchart TD
    subgraph PROCESSOS ["PARADIGMAS DE PROCESSO"]
        W["🌊 Cascata (Waterfall)<br>Sequencial & Preditivo"]
        I["🔄 Incremental / Iterativo<br>Entregas Parciais & Evolutivas"]
        P["🎨 Prototipação<br>Validação de UI & Descoberta"]
        E["🌀 Espiral (Boehm)<br>Orientado a Riscos & Ciclos"]
    end
    
    style W fill:#e1f5fe,stroke:#0284c7
    style I fill:#dcfce7,stroke:#16a34a
    style P fill:#fef3c7,stroke:#d97706
    style E fill:#f3e5f5,stroke:#7b1fa2

3.2. Cascata vs. Incremental: Análise de Custo da Mudança

No modelo Cascata, o custo de corrigir um requisito mal compreendido na fase de testes pode ser até 100× maior do que na fase inicial de elicitação. No modelo Incremental, o feedback frequente reduz o retrabalho.

flowchart LR
    subgraph Cascata ["🌊 Modelo Cascata"]
        R1["Requisitos"] --> D1["Design"] --> C1["Código"] --> T1["Testes"] --> O1["Operação"]
    end
    
    subgraph Incremental ["🚀 Modelo Incremental"]
        direction TB
        Inc1["Incremento 1: MVP Core (4 semanas)"]
        Inc2["Incremento 2: Pagamentos & API (3 semanas)"]
        Inc3["Incremento 3: Relatórios & BI (3 semanas)"]
        Inc1 --> Inc2 --> Inc3
    end
    
    style Cascata fill:#fee2e2,stroke:#ef4444
    style Incremental fill:#dcfce7,stroke:#16a34a

💻 4. Aplicação Prática & Código Executável (Python 3.11+)

Implementação de um motor de ciclo de vida de fases de projeto com validação estrita de transições.

📋 Pré-requisitos e Instalação

Este módulo utiliza exclusivamente recursos nativos do Python 3.11+ (enum). Nenhuma instalação externa é necessária:

# Ambiente padrão Python 3.11+ (sem dependências externas)

💻 Código Completo e Autocontido (ciclo_vida_processo.py)

Crie o arquivo ciclo_vida_processo.py e insira o código abaixo:

"""
Módulo: ciclo_vida_processo.py
Domínio: Automação e rastreamento de estágios do processo de software.
Stack: Python 3.11+
"""
from enum import Enum, auto

class FaseProcesso(Enum):
    CONCEPCAO = auto()
    REQUISITOS = auto()
    DESENHO_ARQUITETURAL = auto()
    IMPLEMENTACAO = auto()
    TESTES_INTEGRACAO = auto()
    DEPLOY_PRODUCAO = auto()

class CicloVidaProjeto:
    def __init__(self, nome_projeto: str, modelo: str = "INCREMENTAL"):
        self.nome_projeto = nome_projeto
        self.modelo = modelo
        self.fase_atual = FaseProcesso.CONCEPCAO
        self.historico_fases: list[FaseProcesso] = [self.fase_atual]

    def transicionar(self, proxima_fase: FaseProcesso, criterios_aceite_atendidos: bool):
        """Valida se os critérios de qualidade da fase atual foram satisfeitos antes de avançar."""
        if not criterios_aceite_atendidos:
            raise PermissionError(
                f"❌ Transição bloqueada: Critérios de aceite incompletos para sair de {self.fase_atual.name}."
            )
        self.fase_atual = proxima_fase
        self.historico_fases.append(self.fase_atual)
        print(f"🚀 [{self.nome_projeto}] Avançou com sucesso para a fase: {self.fase_atual.name}")

if __name__ == "__main__":
    projeto_core = CicloVidaProjeto("TecPro-Telemetria", modelo="CASCATA")

    # 1. Avançando com critérios satisfeitos
    projeto_core.transicionar(FaseProcesso.REQUISITOS, criterios_aceite_atendidos=True)
    projeto_core.transicionar(FaseProcesso.DESENHO_ARQUITETURAL, criterios_aceite_atendidos=True)

    # 2. Tentativa de avanço com pendências de qualidade
    try:
        projeto_core.transicionar(FaseProcesso.IMPLEMENTACAO, criterios_aceite_atendidos=False)
    except PermissionError as err:
        print(err)

🚀 Como Executar

Execute o script no terminal:

python ciclo_vida_processo.py

🖥️ Saída Esperada no Terminal

🚀 [TecPro-Telemetria] Avançou com sucesso para a fase: REQUISITOS
🚀 [TecPro-Telemetria] Avançou com sucesso para a fase: DESENHO_ARQUITETURAL
❌ Transição bloqueada: Critérios de aceite incompletos para sair de DESENHO_ARQUITETURAL.

💡 5. Checkpoint de Engenharia & Boas Práticas

🔗 6. Conexão com os Projetos Integradores

🧪 7. Quiz de Fixação e Autoavaliação (Formative Assessment)

🛠️ 8. Ponte para a Ação: Laboratório Prático

📌 9. Resumo Executivo & Key Takeaways

• Processos são Guias: Um processo de software estrutura as atividades da equipe para transformar requisitos de negócio em valor de produção com previsibilidade.
• Modelo Cascata: Adequado para domínios altamente regulados e com requisitos imutáveis; vulnerável a mudanças tardias.
• Modelo Incremental: Base das metodologias ágeis modernas; reduz o risco de construir o produto errado ao colher feedback contínuo.
• Modelo Espiral: Abordagem de alta maturidade com ênfase na identificação e neutralização antecipada de riscos técnicos e de negócio.