 |
| Bellacosa Mainframe e os design pattern em cobol mainframe |
☕ Um Café no Bellacosa Mainframe
Design Patterns no COBOL Mainframe
Os Padrões que os Grandes Programadores Sempre Usaram (Mesmo Antes de Eles Receberem um Nome)
"Todo programador COBOL iniciante acredita que um bom sistema nasce de um bom código. O programador experiente sabe que um bom sistema nasce de boas decisões de arquitetura."
Existe uma curiosidade fascinante na história da computação.
Quando ouvimos falar em Design Patterns, quase todo mundo lembra imediatamente do famoso livro Design Patterns: Elements of Reusable Object-Oriented Software, publicado em 1994 pelo famoso Gang of Four (GoF).
Muitos acreditam que os padrões nasceram ali.
Mas isso não é verdade.
Na realidade, os profissionais de Mainframe utilizavam padrões muito antes de eles receberem nomes elegantes.
Os sistemas bancários dos anos 70, 80 e 90 já possuíam separação de responsabilidades, reutilização de código, módulos especializados, camadas de acesso a banco, mecanismos de validação, tratamento centralizado de erros, componentes compartilhados e arquiteturas extremamente organizadas.
Eles simplesmente não chamavam isso de Pattern.
Chamavam de:
"Boa programação."
E existe um motivo simples.
Quando um sistema precisa sobreviver por 40 anos, processar bilhões de transações e nunca parar, improvisação não funciona.
É por isso que aprender Patterns em COBOL significa aprender como os grandes sistemas do mundo realmente funcionam.
Hoje vamos explorar essa jornada.
Pegue seu café.
Vamos entrar na mente dos arquitetos que construíram os sistemas que movimentam praticamente todo o dinheiro do planeta.
O que é um Pattern?
Pattern significa literalmente:
Padrão de solução.
Não é código.
Não é framework.
Não é biblioteca.
É uma maneira comprovada de resolver um problema recorrente.
Sempre que um problema aparece repetidamente, alguém encontra uma solução elegante.
Depois de milhares de aplicações, essa solução vira um padrão.
A origem dos Patterns
Antes mesmo da computação, um arquiteto chamado Christopher Alexander estudava cidades e construções.
Ele percebeu algo interessante.
As melhores cidades do mundo utilizavam soluções semelhantes para problemas semelhantes.
Uma praça.
Uma rua.
Uma entrada.
Uma janela.
Tudo seguia padrões.
Em 1977 ele publicou:
A Pattern Language.
Décadas depois, programadores perceberam:
"Software também possui problemas repetitivos."
Assim nasceram os Design Patterns modernos.
Mas... e o Mainframe?
Enquanto isso...
Em grandes bancos...
Seguradoras...
Governos...
Empresas aéreas...
Os analistas já utilizavam exatamente a mesma filosofia.
Um exemplo clássico.
Em vez de cada programa acessar DB2 diretamente...
Criava-se um módulo responsável apenas por isso.
Hoje chamaríamos isso de:
DAO Pattern.
Na época era apenas:
"O módulo que conversa com o banco."
Por que Patterns são importantes?
Imagine um hospital.
Você não quer que cada médico invente sua própria forma de operar.
Existe um procedimento.
Uma sequência.
Uma organização.
Software crítico funciona da mesma forma.
Patterns tornam sistemas:
previsíveis
fáceis de manter
fáceis de evoluir
seguros
reutilizáveis
Pattern 1 — Modularização
O primeiro pattern da história do Mainframe.
Um programa enorme faz tudo.
Depois de alguns anos...
Ninguém entende mais nada.
A solução?
Separar responsabilidades.
Exemplo:
Programa Principal
↓
Validação
↓
Regras de Negócio
↓
DB2
↓
Relatórios
↓
Logs
Cada módulo possui apenas uma função.
Hoje isso parece óbvio.
Na década de 70 era revolucionário.
Como aplicar
Nunca escreva um programa de 5.000 linhas.
Pergunte:
Esta rotina pode virar um subprograma?
Se a resposta for sim...
Faça isso.
Pattern 2 — COPYBOOK Pattern
Uma das maiores invenções do COBOL.
Em vez de repetir estruturas...
Criamos COPYBOOKS.
Exemplo:
Cliente
Conta
Saldo
Endereço
CPF
Esses campos aparecem em centenas de programas.
Sem COPYBOOK...
Bastaria alterar um campo para criar centenas de inconsistências.
Com COPYBOOK...
Uma alteração.
Todos utilizam.
Boas práticas
Nunca copie estruturas manualmente.
Sempre centralize.
Pattern 3 — Validation Layer
Nunca misture validação com regra de negócio.
Errado:
Recebe CPF
Consulta DB2
Calcula juros
Valida CPF
Atualiza saldo
Tudo misturado.
Certo:
Entrada
↓
Validação
↓
Negócio
↓
Persistência
Benefícios
Código mais limpo.
Testes mais simples.
Menos bugs.
Pattern 4 — Error Handler Centralizado
Um clássico absoluto.
Em vez de cada programa escrever mensagens diferentes...
Existe um módulo especializado.
Exemplo:
DISPLAY
ABEND
LOG
RETURN-CODE
Tudo passa por um componente comum.
Vantagens
Padronização.
Auditoria.
Facilidade de suporte.
Pattern 5 — File Access Layer
Em vez de cada programa abrir arquivos VSAM...
Criamos uma camada.
Programa
↓
Arquivo Layer
↓
VSAM
Se amanhã o arquivo virar DB2...
O programa quase não muda.
Isso é desacoplamento
A lógica de negócio não conhece detalhes físicos.
Esse conceito ficou famoso décadas depois.
No Mainframe já era realidade.
Pattern 6 — Database Access Layer
Muito comum em DB2.
Programa
↓
Subprograma SQL
↓
DB2
O programa não conhece SQL.
Conhece apenas serviços.
Exemplo:
Consultar Cliente
Atualizar Saldo
Inserir Conta
Excluir Registro
Muito semelhante aos Repository Patterns modernos.
Pattern 7 — Service Programs
Grandes empresas possuem centenas de programas.
Algumas regras aparecem em todos.
Cálculo de CPF.
Validação de agência.
Máscara.
Data.
Moeda.
Essas regras viram serviços.
Exemplo
CALL "CALCJURO"
CALL "VALIDCPF"
CALL "FORMATA"
CALL "DATAUTIL"
Isso reduz milhares de linhas duplicadas.
Pattern 8 — Dispatcher
Muito usado em CICS.
Um programa recebe uma operação.
Dependendo da função...
Chama outro programa.
Entrada
↓
Dispatcher
↓
Consulta
↓
Inclusão
↓
Alteração
↓
Exclusão
Hoje chamamos isso de Command Dispatcher.
Pattern 9 — Table Driven Programming
Em vez de dezenas de IF...
Utilize tabelas.
Errado:
IF UF = SP
IF UF = RJ
IF UF = MG
...
Melhor:
Tabela de estados.
Pesquisa.
Resultado.
Menos código.
Mais manutenção.
Pattern 10 — Configuration Pattern
Nunca coloque constantes espalhadas.
Crie parâmetros.
Copybooks.
Arquivos.
Tabelas.
Isso evita recompilar programas para pequenas mudanças.
Pattern 11 — Batch Pipeline
Muito usado em processamento noturno.
Leitura
↓
Validação
↓
Transformação
↓
Classificação
↓
Carga
Cada etapa faz apenas uma coisa.
Se uma falhar...
A anterior permanece íntegra.
Pattern 12 — Restart Pattern
Um dos mais importantes.
Imagine um Batch de 8 horas.
Na hora 7 ocorre falha.
Sem Restart...
Tudo começa novamente.
Com Restart...
Continua do último checkpoint.
Essa ideia economiza milhões de dólares todos os anos.
Pattern 13 — Checkpoint Pattern
Muito usado com IMS.
A cada quantidade de registros...
Grava-se um ponto seguro.
Em caso de falha...
Retorna dali.
Pattern 14 — Logging Pattern
Nunca dependa apenas do DISPLAY.
Registre:
Programa
Data
Hora
Usuário
Arquivo
SQLCODE
Chave
Operação
Isso salva equipes inteiras durante incidentes.
Pattern 15 — Retry Pattern
DB2 indisponível?
Arquivo bloqueado?
MQ ocupado?
Em vez de falhar imediatamente...
Tente novamente algumas vezes.
Mas cuidado.
Retry infinito vira desastre.
Pattern 16 — Circuit Breaker (Modernização)
Muito usado via APIs.
Se um serviço externo está indisponível...
Pare de chamá-lo temporariamente.
Evita sobrecarga.
Pattern 17 — Adapter
Muito utilizado na modernização.
Sistema antigo
↓
Adapter
↓
API REST
O COBOL permanece praticamente igual.
Pattern 18 — Facade
Imagine vinte programas acessando vinte módulos.
Complicado.
Criamos uma fachada.
Programa
↓
Facade
↓
Serviços internos
Tudo fica mais simples.
Pattern 19 — Strategy
O cálculo muda conforme o produto.
Em vez de centenas de IF...
Criamos estratégias.
Produto A
↓
Regra A
Produto B
↓
Regra B
Produto C
↓
Regra C
Pattern 20 — Template Process
Muito comum em Batch.
Todos os programas fazem:
Inicialização
Leitura
Processamento
Gravação
Fechamento
Apenas a lógica muda.
A estrutura permanece.
Como identificar quando usar um Pattern
Faça cinco perguntas:
Estou repetindo código?
Esse módulo possui mais de uma responsabilidade?
Se mudar amanhã, quantos programas serão alterados?
Consigo testar isoladamente?
Outra equipe entenderia isso facilmente?
Se várias respostas forem "não"...
Provavelmente existe um Pattern melhor.
Os erros mais comuns dos iniciantes
O famoso "programa monolítico".
Tudo dentro da PROCEDURE DIVISION.
Milhares de linhas.
GO TO para todos os lados.
Variáveis globais.
DISPLAY espalhados.
SQL misturado.
Validação misturada.
Regras misturadas.
Esse tipo de programa funciona...
Até o primeiro incidente em produção.
Como evoluir como Programador COBOL
Existe uma evolução natural.
Nível 1
Aprende sintaxe.
MOVE.
IF.
PERFORM.
READ.
WRITE.
Nível 2
Aprende organização.
Seções.
Parágrafos.
COPYBOOKS.
Subprogramas.
Nível 3
Aprende Patterns.
Reutilização.
Arquitetura.
Modularização.
Nível 4
Aprende integração.
DB2.
CICS.
IMS.
MQ.
REST.
JSON.
Nível 5
Pensa como arquiteto.
Nesse ponto, você não escreve apenas programas.
Você desenha soluções.
Curiosidades
Muitos sistemas bancários escritos há mais de 35 anos continuam ativos porque seguiram padrões consistentes.
Diversos conceitos popularizados em Java, C# e outras linguagens já eram praticados em ambientes COBOL, ainda que com nomes diferentes.
O uso disciplinado de COPYBOOKS foi um dos fatores que permitiu manter aplicações enormes sincronizadas por décadas.
Grandes equipes de Mainframe costumam definir padrões internos de nomenclatura, tratamento de erros, chamadas de subprogramas e acesso a dados para reduzir riscos operacionais.
Melhores práticas para o dia a dia
Dê a cada programa uma responsabilidade clara.
Evite duplicação de lógica.
Centralize estruturas em COPYBOOKS.
Padronize mensagens de erro.
Isole acesso a arquivos e bancos de dados.
Documente interfaces de subprogramas.
Use nomes consistentes para programas, parágrafos e variáveis.
Escreva código pensando em quem fará a manutenção daqui a dez anos.
Prefira simplicidade à esperteza.
Revise continuamente seu código procurando oportunidades de extrair novos módulos reutilizáveis.
O futuro dos Patterns no Mainframe
O Mainframe moderno conversa com APIs REST, mensageria, microsserviços, Kubernetes, aplicações Java, Python e serviços em nuvem. Nesse cenário, os Patterns clássicos continuam mais relevantes do que nunca. Adapter, Facade, Retry, Circuit Breaker, Service Layer e Repository ajudam a integrar aplicações COBOL com tecnologias modernas sem sacrificar estabilidade.
O profissional que domina esses conceitos deixa de ser apenas um desenvolvedor de programas e passa a ser um engenheiro de soluções. Ele entende quando reutilizar, quando desacoplar, quando encapsular e quando simplificar. Esse conhecimento vale muito mais do que decorar comandos da linguagem.
Conclusão
Existe uma frase muito conhecida entre arquitetos de software:
"Código ruim pode funcionar. Arquitetura ruim cobra juros."
No universo IBM Z, essa cobrança aparece em horas extras, incidentes de produção, dificuldades de manutenção e projetos de modernização cada vez mais caros.
Os Patterns existem justamente para evitar esse cenário. Eles representam décadas de experiência acumulada por milhares de profissionais que enfrentaram os mesmos problemas e encontraram soluções elegantes, reutilizáveis e seguras.
Se você é um Programador COBOL Padawan, não tente memorizar todos os Patterns de uma vez. Comece pelos mais importantes: modularização, COPYBOOKS, validação, tratamento centralizado de erros, acesso a dados desacoplado e reutilização de serviços. À medida que sua experiência crescer, você perceberá que esses padrões aparecem naturalmente em praticamente todos os grandes sistemas corporativos.
Lembre-se: escrever código é uma habilidade. Escrever código que continuará funcionando e sendo compreendido daqui a vinte anos é uma arte. E essa arte é construída com disciplina, boas práticas e padrões sólidos.
No Bellacosa Mainframe, costumamos dizer que o verdadeiro poder de um Programador COBOL não está na quantidade de comandos que ele conhece, mas na qualidade das decisões que toma antes mesmo de começar a digitar a primeira linha de código.
Esse é o caminho que transforma um Padawan em um verdadeiro Mestre do Mainframe.
Se desejar, posso criar a Parte 2 com mais de 3.000 palavras, abordando 40+ Design Patterns específicos para COBOL, CICS, DB2, IMS, Batch, APIs REST, MQ e modernização no IBM Z, com exemplos completos de código COBOL para cada padrão.
