☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta mq. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta mq. Mostrar todas as mensagens

quarta-feira, 26 de agosto de 2026

🚀 A Hidrelétrica Digital — Quando o Agente J Entrou na Sala de Controle do z/OS e Descobriu que Cem Alertas Não Eram Cem Problemas

 

Bellacosa Mainframe e a hidreletrica digital monitorando um mainframe

☕ Um Café no Bellacosa Mainframe

🚀 A Hidrelétrica Digital — Quando o Agente J Entrou na Sala de Controle do z/OS e Descobriu que Cem Alertas Não Eram Cem Problemas

Ou: o mainframe não precisava de mais pares de olhos diante de dashboards; precisava de sensores, contexto, bons procedimentos e alguém que não apertasse o botão vermelho só porque Igor disse que a luz estava piscando

O Agente J, recém-saído de mais uma manhã tentando explicar ao público que alienígenas não usavam cartão de ponto, entrou no centro de operações e parou diante de uma parede de telas. Havia gráficos verdes, amarelos, vermelhos, mapas de aplicações, filas, porcentagens de CPU, mensagens de console, tickets e, em um canto suspeito, um operador olhando para o JES como quem esperava que ele revelasse o futuro nas entranhas de um SYSOUT.

— Então é aqui que vocês protegem o banco? — perguntou J.

— Em tese — respondeu o Agente K. — Em prática, às vezes protegemos o banco de 97 alertas que são a mesma coisa usando fantasias diferentes.

O colega apontou para a tela. A CPU estava alta. Uma fila MQ crescia. O Db2 apresentava espera. Uma transação CICS ficava lenta. Um job batch ultrapassara o horário previsto. A API móvel exibia aumento de timeout.

— São seis incidentes? — J perguntou.

K colocou os óculos escuros, porque alguma instituição provavelmente ainda não havia inventado um protocolo para isso.

— Talvez seja um só. Esse é o problema.

É aí que começa a conversa sobre Mainframe Operations inteligente. Não se trata de substituir o operador L1, o analista L2, o DBA, o especialista CICS ou aquela pessoa que conhece uma regra de negócio tão antiga que parece ter sido entregue junto com o primeiro cartão perfurado. Trata-se de parar de usar profissionais experientes como sensores biológicos de dashboard.

O mainframe continua sendo uma das salas de máquinas mais confiáveis do mundo. Mas confiável não significa simples. Ele conversa com aplicações web, mobile, APIs, nuvens, filas, parceiros, cartões, pagamentos, batches, sistemas de fraude e uma coleção de integrações que, em alguns bancos, já possui mais dependências do que a árvore genealógica dos Targaryen. Observar tudo isso apenas olhando telas é como operar uma hidrelétrica com uma lanterna e um caderninho.


A hidrelétrica que, por acaso, processa pagamentos

A melhor analogia para entender AIOps no mainframe é uma hidrelétrica moderna.

Uma usina possui centenas ou milhares de sinais: nível da água, vazão, pressão, vibração, temperatura, rotação da turbina, posição de comportas, tensão, frequência e estado de equipamentos. Um sensor isolado raramente conta a história inteira. Uma vibração levemente maior pode ser normal. Vibração crescente junto com temperatura elevada, perda de eficiência e alteração de pressão é outra conversa: alguém precisa investigar antes que a conversa vire notícia.

O ambiente z/OS tem seus próprios sensores:

  • CPU, memória, dispatching e metas de serviço do WLM;

  • I/O, canais, volumes e espaço de DASD;

  • jobs, initiators, spool e mensagens do JES2;

  • tempos de resposta e regiões do CICS;

  • locks, waits, pools e SQL no Db2;

  • filas, canais e consumidores no MQ;

  • transações IMS e conectividade TCP/IP;

  • logs, traces, mensagens do console e registros SMF;

  • latência de APIs, erros de aplicativos e experiência do cliente.

O cliente, no entanto, não vê nenhum desses itens. Ele vê uma pergunta de cinco segundos: “o PIX foi?”, “o pagamento entrou?”, “consigo consultar meu saldo?”, “a folha fechou?”.

Por isso, operação madura não monitora apenas componentes. Ela monitora serviços de negócio e usa os componentes para explicar o que aconteceu com eles.

CPU alta numa LPAR pode ser apenas o processamento esperado do fechamento. CPU alta, fila MQ crescendo, transação CICS acima do SLO e timeout no app bancário é uma tempestade se formando. A diferença não está no gráfico; está no contexto.


Antes da IA: alerta, evento, incidente, problema e mudança

Em operações, algumas palavras são tratadas como sinônimos até o dia em que deixam de ser. Vale colocá-las em ordem antes de dar uma pistola neuralizadora ao dashboard.

Um evento é qualquer ocorrência observável: uma mensagem no console, um job terminando, uma conexão caindo, uma alteração de estado. Um alerta é um evento que cruza uma regra de atenção: a fila passou de determinado tamanho, o tempo de resposta ultrapassou um limite, um recurso ficou indisponível.

Um incidente é quando um serviço está interrompido ou degradado. “Clientes não conseguem pagar” é incidente. Já um problema é a causa persistente ou subjacente que pode produzir vários incidentes: um plano SQL ruim, uma parametrização incorreta, um vazamento de recurso, um processo batch concorrendo de modo inadequado.

E há a mudança: o deploy, ajuste de parâmetro, manutenção ou alteração de configuração que pode ser a solução, a causa ou uma coincidência muito suspeita.

O erro clássico do monitoramento tradicional é transformar cada alerta em um incidente. Assim, uma única regressão após um deploy gera tickets separados para API, CICS, Db2, MQ, rede e storage. Cada equipe recebe seu fragmento do elefante e conclui que a culpa está em outra sala.

O objetivo da correlação é fazer o caminho oposto: agrupar os sintomas e apresentar um incidente operacional coerente.

Incidente: Pagamentos digitais degradados.
Impacto: clientes com timeout acima de três segundos.
Serviços envolvidos: API Payments → CICS PAYM → Db2 DBPAY → MQ.
Início: logo após a mudança CHG004321.
Hipótese: aumento de chamadas e regressão de plano SQL.
Próximo passo: coletar evidências e executar runbook aprovado.

Note a palavra importante: hipótese. Uma plataforma inteligente deve apresentar causa provável e nível de confiança, não posar de oráculo. Correlação temporal é valiosa; não é prova definitiva de causalidade.



O que as ferramentas trazem para a sala de controle

Ferramentas como IBM OMEGAMON, BMC AMI Ops e Broadcom SYSVIEW dão visibilidade profunda de z/OS e seus subsistemas. Elas ajudam a enxergar o que realmente acontece na LPAR, no CICS, no Db2, no MQ, no IMS, no JES e nos recursos que sustentam a carga. São os instrumentos de engenharia da usina.

IBM Z System Automation, NetView e soluções como OPS/MVS entram mais diretamente na parte de automação orientada a eventos, disponibilidade e ações controladas. Elas podem detectar estados, aplicar políticas e disparar procedimentos conhecidos.

No outro extremo da jornada, plataformas de observabilidade como Instana, Dynatrace e AppDynamics ajudam a costurar a visão de ponta a ponta: o clique no aplicativo, a API, o middleware, a transação no mainframe e o retorno ao cliente. Splunk e Elastic podem centralizar logs, eventos e análises, desde que os dados tenham qualidade, horário confiável e acesso devidamente protegido. ServiceNow organiza o processo: ticket, mudança, aprovação, SLA, escalonamento, CMDB e workflow.

O detalhe que slides de marketing omitem é este: nenhuma dessas ferramentas, isoladamente, é AIOps. A inteligência aparece na integração.

Um monitor detecta a anomalia. A topologia informa as dependências. A CMDB identifica o serviço e seu dono. O histórico aponta o comportamento esperado. O motor de correlação reduz o ruído. O ServiceNow abre um incidente já enriquecido. A automação executa uma ação de baixo risco. E a observabilidade confirma se o serviço voltou a funcionar.

Sem esse encadeamento, temos várias telas bonitas. Com ele, temos uma sala de controle.


Threshold estático: o velho porteiro ainda tem emprego

“Alerta quando CPU ultrapassar 90%.” É uma regra simples, útil e incompleta.

Às duas da manhã, no processamento mensal, 90% pode ser esperado. Às duas da tarde, numa LPAR que normalmente opera a 45%, 65% pode ser a primeira pista de algo muito estranho. É aqui que entram baseline, sazonalidade e detecção de anomalia.

Uma boa análise pergunta:

  • este comportamento é normal para este horário e este dia?

  • houve alteração abrupta, mesmo abaixo do limite absoluto?

  • quais métricas se moveram juntas?

  • qual serviço de negócio foi afetado?

  • houve mudança, deploy ou manutenção recente?

  • o impacto é crescente ou estável?

Mas não se deve jogar fora os limites rígidos. Espaço de DASD quase esgotado, fila aproximando-se de limite físico, certificado prestes a expirar e recurso indisponível não precisam aguardar uma tese de machine learning. O ambiente maduro combina limites determinísticos para riscos claros e anomalias estatísticas para padrões sutis.

O Agente J resumiria assim: “Se o reservatório está transbordando, não vamos montar um comitê para saber se a água parece incomumente molhada.”



Do alerta ao incidente: um caso de banco digital

Imagine que, às 10h05, clientes começam a relatar lentidão ao efetuar pagamentos.

No modo antigo, L1 abre o dashboard da aplicação e vê timeout. Depois consulta CICS e identifica transações com maior tempo de resposta. Abre Db2 e encontra waits. Vai ao SDSF verificar jobs. Olha MQ. Procura mensagens. Cria ticket. Escala para L2, DBA, middleware, infraestrutura e, por segurança, para a equipe que fez o último deploy. Todos começam a investigar ângulos diferentes.

No modelo inteligente, as informações chegam correlacionadas. A plataforma observa que:

  • a jornada “pagamento digital” ultrapassou seu SLO;

  • a API Payments aumentou o volume de requisições;

  • a transação CICS PAYM ficou lenta;

  • o Db2 mostrou aumento de waits e uma consulta específica mudou de comportamento;

  • a fila MQ começou a acumular mensagens;

  • tudo teve início minutos após uma mudança registrada.

O L1 não recebe seis sirenes. Recebe um incidente com impacto, dependências, evidências, possíveis responsáveis e runbook.

Isso não elimina a investigação técnica. Elimina a caça ao tesouro inicial — aquela meia hora em que cada pessoa tenta descobrir se o incêndio é real, onde começou e quem tem a chave do armário de mangueira.

Para um programador COBOL iniciante, existe uma lição excelente aí: seu PROGRAM-ID quase nunca vive sozinho. Uma rotina aparentemente inocente pode chamar Db2, publicar em MQ, ser acionada por CICS, expor dados por API e participar de um fluxo que movimenta dinheiro. Aprender a observar o caminho da transação é tão importante quanto acertar o PERFORM.



Self-healing sem transformar Igor em DBA de produção

Automação de recuperação é maravilhosa até alguém programar uma rotina para derrubar uma região CICS crítica por causa de um alerta mal calibrado. Por isso, “self-healing” precisa ser dividido por risco.

Há ações ótimas para automação total:

  • coletar logs, mensagens, dumps e métricas quando surge uma anomalia;

  • abrir e enriquecer incidentes;

  • executar health checks;

  • reiniciar um processo isolado e conhecido;

  • elevar temporariamente o nível de monitoramento;

  • pausar uma cadeia batch antes que um erro se propague;

  • fazer a notificação e o escalonamento corretos.

Outras ações devem ser assistidas ou requerer aprovação:

  • cancelar batch crítico;

  • alterar WLM;

  • modificar parâmetro Db2;

  • derrubar ou reciclar região compartilhada;

  • fazer failover;

  • alterar RACF, certificados, conectividade ou regras de segurança;

  • realizar rollback de aplicação.

A regra de ouro é simples: quanto maior o raio de explosão, maior a necessidade de aprovação humana, trilha de auditoria e rollback.

Uma hidrelétrica não permite que um algoritmo abra todas as comportas porque um sensor piscou. Ela trabalha por níveis: automático para ajustes seguros e reversíveis; assistido para recomendações que o operador aprova; manual para decisões críticas. A operação de mainframe deveria seguir exatamente essa filosofia.

Igor, naturalmente, propôs colocar CANCEL JOB(*) dentro de um botão verde chamado “cura automática”. O Agente K confiscou o teclado. Segurança também é uma forma de carinho.



L1 e L2: menos mensageiros, mais operadores de exceção

A evolução não diminui o valor de L1 e L2; ela muda o tipo de valor entregue.

L1 deixa de ser a pessoa que copia mensagens de console para um ticket e pode se tornar operador de exceções: valida impacto, executa runbooks aprovados, confirma se a correção funcionou, faz comunicação operacional e escalona com evidências.

L2 ganha espaço para trabalho que diminui as próximas madrugadas ruins: análise de causa raiz, ajuste de alertas, automações, gestão de capacidade, revisão de arquitetura, melhoria de runbooks e eliminação de falhas recorrentes.

Isso é próximo da cultura de SRE: não basta apagar incêndio com eficiência; é preciso descobrir por que o prédio continua tendo incêndios na mesma tomada.



A parte chata que salva o projeto: dados, nomes e procedimentos

Antes de contratar uma IA com nome de nave espacial, arrume a base.

Se a aplicação é chamada de PAGTO no mainframe, “Pix” pelo negócio, “Payments Hub” na CMDB e APP-347 no dashboard, a ferramenta não ganhou contexto; ganhou quatro identidades secretas para o mesmo serviço. Nem o MIB tem orçamento para isso.

Os obstáculos reais costumam ser:

  • alertas duplicados ou sem dono;

  • topologia e CMDB desatualizadas;

  • logs sem correlação, timestamp confiável ou padronização;

  • mudanças sem registro operacional;

  • runbooks velhos, incompletos ou guardados na cabeça de uma única pessoa;

  • ausência de SLOs e indicadores de impacto de negócio;

  • automações sem teste, validação ou rollback;

  • permissões excessivas em contas técnicas.

Lembre-se: IA alimentada por telemetria ruim apenas produz conclusões ruins com uma confiança irritantemente bem redigida.



Um roteiro possível para começar

Não tente modernizar todos os alertas do universo numa única change. Comece pequeno, mensurável e dolorosamente real.

Primeiro: reduza ruído. Revise alertas. Cada alerta deve ter dono, severidade, ação esperada e justificativa. Se ninguém sabe o que fazer quando ele dispara, provavelmente não é alerta; é decoração sonora.

Segundo: escolha jornadas críticas. Pagamento, PIX, cartão, fechamento, folha, faturamento, autorização. Comece por aquilo cuja indisponibilidade o negócio percebe em minutos.

Terceiro: mapeie dependências. Desenhe API, middleware, CICS/IMS, Db2, MQ, batch, rede, storage e terceiros. A pergunta é: “se isto falhar, quem sente?”

Quarto: escreva runbooks utilizáveis. Não um PDF de 200 páginas enterrado no SharePoint. Um procedimento que diga sintomas, verificações, comandos autorizados, evidências, critérios de parada, escalonamento e rollback.

Quinto: automatize a coleta antes da correção. Fazer a máquina montar um ticket excelente e reunir evidências já reduz muito MTTR. Automação de remediação vem depois, em ações reversíveis e testadas.

Sexto: correlacione casos recorrentes. Se três incidentes por mês começam com a mesma combinação de sinais, essa é uma ótima primeira regra. A automação deve nascer de dor repetida, não de entusiasmo em reunião.

Sétimo: valide o resultado. Uma ação só é recuperação se o serviço voltou ao SLO. Reiniciar uma tarefa e fechar o ticket porque o alerta sumiu é como desligar o alarme de incêndio e declarar que a fumaça foi embora.



O que medir para saber se a inteligência existe

Não conte telas, licenças ou gráficos com inteligência artificial desenhada no canto. Meça resultado:

  • quantidade de alertas por incidente real;

  • redução de ruído;

  • MTTA, o tempo até reconhecer o incidente;

  • MTTR, o tempo até restaurar o serviço;

  • percentual de incidentes detectados antes do cliente;

  • taxa de sucesso e falha das automações;

  • reincidência dos principais problemas;

  • percentual de tickets enriquecidos automaticamente;

  • cobertura de serviços críticos com SLO e dependências mapeadas.

O indicador mais honesto é simples: o operador passa menos tempo caçando pistas e mais tempo prevenindo a próxima falha?



Epílogo — Não é Skynet; é uma usina bem operada

Mainframe Operations inteligente não é dar autonomia ilimitada a um modelo e esperar que ele descubra o significado de IEC161I enquanto a produção queima. É criar uma operação que coleta sinais, entende dependências, relaciona tecnologia com negócio, aplica procedimentos seguros e mantém pessoas experientes no circuito.

O futuro não é “menos humanos”. É menos trabalho mecânico, menos escalonamento cego, menos alertas inúteis e mais inteligência aplicada ao que realmente importa.

Quando o Agente J saiu da sala, perguntou se poderia usar o neuralyzer para apagar da memória dos operadores todos os alertas duplicados.

K balançou a cabeça.

— Não. Primeiro precisamos corrigir a regra que os gera.

E aquele, para quem já enfrentou uma madrugada de console cheio e café frio, foi o momento mais sensato de toda a operação.

Easter egg para quem viveu o mainframe: se um dashboard declarar tudo verde enquanto o usuário reclama que nada funciona, desconfie. Talvez não seja uma invasão alienígena. Talvez alguém esteja monitorando o recurso certo… para o serviço errado.

quinta-feira, 25 de junho de 2026

Technical Debt, Chaos Engineering e Resiliência no Mundo COBOL

 

Bellacosa Mainframe e divida tecnica, engenharia do caos e resiliencia no mundo mainframe

☕ Um Café no Bellacosa Mainframe

Technical Debt, Chaos Engineering e Resiliência no Mundo COBOL

Uma viagem dos cartões perfurados à engenharia de confiabilidade moderna

Existe uma curiosidade interessante sobre o universo Mainframe.

Boa parte dos desenvolvedores mais jovens acredita que sistemas COBOL foram escritos uma única vez, colocados em produção em algum momento dos anos 80 e simplesmente ficaram funcionando até hoje, imutáveis, como fósseis tecnológicos preservados em um museu digital.

A realidade é completamente diferente.

Poucas plataformas de tecnologia evoluíram tanto quanto o ecossistema IBM Z.

O hardware mudou.

O sistema operacional mudou.

Os compiladores mudaram.

As técnicas de desenvolvimento mudaram.

A forma de entregar software mudou.

As exigências regulatórias mudaram.

E os desenvolvedores também precisaram mudar.

Hoje falamos sobre APIs REST, Git, DevOps, Inteligência Artificial, Observabilidade, Chaos Engineering e Cloud Native. Entretanto, curiosamente, os sistemas que movimentam bilhões de dólares por dia continuam sendo executados por programas COBOL escritos há décadas.

Seria isso uma contradição?

Na verdade, não.

Talvez seja justamente uma demonstração de sucesso.

O primeiro legado não foi um erro

Em 1959 nasceu o COBOL.

Naquela época não existiam metodologias ágeis.

Não existia internet.

Não existiam smartphones.

Muitos programas eram escritos em cartões perfurados.

Armazenamento era caro.

Memória era limitada.

CPU era um recurso precioso.

As equipes construíam software pensando em algo muito importante:

Confiabilidade.

A aplicação precisava funcionar.

Sempre.

Mesmo que demorasse algumas horas para processar milhares de contas bancárias durante a madrugada.

Foi nesse ambiente que nasceu uma cultura extremamente disciplinada.

Documentação.

Padrões.

Controle de mudanças.

Testes.

Auditorias.

Processos.

Talvez os desenvolvedores daquela época não soubessem, mas estavam criando alguns dos primeiros conceitos de Engenharia de Confiabilidade.

Technical Debt: a dívida que todos nós fazemos

Em 1992, Ward Cunningham criou uma analogia brilhante.

Ele comparou decisões de desenvolvimento com empréstimos bancários.

Imagine que você precise entregar um sistema até sexta-feira.

Você poderia construir uma solução perfeita.

Ou poderia desenvolver algo funcional, mais simples, entregando rapidamente.

Você ganha velocidade.

Mas assume uma dívida.

E como toda dívida, ela possui juros.

Esses juros aparecem de várias formas.

Mais bugs.

Mais incidentes.

Mais retrabalho.

Maior consumo de CPU.

Maior dificuldade de manutenção.

Menor velocidade de inovação.

No Mainframe isso acontece frequentemente.

Talvez exista um programa COBOL com 25 mil linhas.

Talvez exista um COPYBOOK criado em 1987.

Talvez apenas um profissional conheça determinada aplicação.

Tudo isso representa dívida técnica.

O problema não é possuir dívida.

O problema é não saber que ela existe.

Nem toda dívida é ruim

Muitos desenvolvedores iniciantes acreditam que Technical Debt sempre significa erro.

Não é verdade.

Às vezes ela é estratégica.

Um banco pode precisar adequar sistemas rapidamente para atender uma nova regulamentação do BACEN.

Uma seguradora pode precisar disponibilizar um novo produto imediatamente.

Uma fintech pode lançar um MVP para validar mercado.

Nesses casos, assumir dívida técnica pode ser perfeitamente aceitável.

Desde que exista um plano para pagá-la posteriormente.

E aqui encontramos uma das primeiras lições importantes para um desenvolvedor COBOL júnior:

Escreva código pensando que alguém precisará entendê-lo daqui a dez anos.

Esse alguém pode ser você mesmo.

O mito da reescrita completa

Existe uma frase bastante comum em empresas:

"Precisamos jogar tudo fora."

Geralmente essa frase surge quando o ambiente está muito complexo.

Mas a IBM apresenta uma visão diferente.

Você não precisa substituir quarenta anos de sistemas.

Você pode modernizar gradualmente.

Esse conceito ficou conhecido como Strangler Pattern.

Imagine um sistema COBOL que processa contas correntes.

Ele continua funcionando.

Mas uma nova camada é criada.

z/OS Connect.

APIs REST.

Microserviços.

Containers.

Aplicações Java.

Python.

Inteligência Artificial.

O COBOL permanece processando transações críticas.

As aplicações modernas apenas consomem seus serviços.

A dívida começa a diminuir sem que seja necessário desligar o coração operacional da empresa.

Testes automatizados são seus melhores amigos

Durante muitos anos, testar em Mainframe significava reservar uma janela de homologação.

Executar jobs.

Analisar relatórios.

Esperar dias.

Hoje isso mudou.

Ferramentas como zUnit permitem criar testes automatizados.

Jenkins integra pipelines.

GitHub Actions executa validações.

DBB facilita builds.

Zowe aproxima o mundo Mainframe das práticas DevOps modernas.

Se você está começando em COBOL, desenvolva o hábito de pensar:

"O que acontece se o CPF estiver inválido?"

"E se a data vier vazia?"

"E se houver overflow?"

Programadores experientes não escrevem apenas funcionalidades.

Eles escrevem confiança.

Code Review: aprendendo com outros desenvolvedores

Uma das melhores maneiras de evoluir tecnicamente é revisar código.

Olhar programas COBOL antigos.

Analisar SQL.

Entender JCLs.

Perguntar.

Questionar.

Aprender.

Muitos problemas são identificados antes mesmo de chegar à produção.

Um cursor esquecido.

Um COMMIT ausente.

Um SORT desnecessário.

Uma consulta DB2 sem índice adequado.

Dois pares de olhos normalmente enxergam mais do que um.

Refatoração não significa reescrever

Refatorar é melhorar.

Não é destruir.

Não é começar do zero.

Pequenas melhorias acumuladas ao longo do tempo fazem enorme diferença.

Renomear variáveis.

Extrair rotinas.

Separar módulos.

Eliminar GOTO.

Criar serviços reutilizáveis.

Transformar programas gigantes em componentes menores.

Refatoração contínua é uma das formas mais eficientes de pagar Technical Debt.

Observabilidade: enxergando o que realmente acontece

Existe uma frase bastante conhecida:

Se você não consegue medir, não consegue melhorar.

No mundo IBM Z temos ferramentas extraordinárias.

SMF.

RMF.

OMEGAMON.

Instana.

Grafana.

Elas permitem compreender:

CPU.

I/O.

Latência.

Filas.

Conexões.

Transações.

Antes de corrigir qualquer problema, precisamos enxergá-lo.

Observabilidade é a base da engenharia moderna.

Chaos Engineering: quebrando para aprender

Talvez o conceito mais surpreendente para desenvolvedores COBOL seja Chaos Engineering.

A ideia surgiu popularmente na Netflix.

Mas a IBM mostra que ela pode ser aplicada em praticamente qualquer ambiente.

O princípio é simples.

Não espere uma falha em produção.

Provoque pequenas falhas.

Aprenda.

Corrija.

Teste novamente.

Por exemplo:

O que acontece se o IMS Connect ficar indisponível?

Se a fila MQ atingir 95% de ocupação?

Se um membro do Sysplex parar?

Se o DB2 responder lentamente?

Chaos Engineering não significa desligar servidores aleatoriamente.

É ciência.

Você cria uma hipótese.

Executa um experimento controlado.

Observa.

Aprende.

Melhora.

Repete.

Resiliência é um investimento

A IBM utiliza uma analogia muito interessante.

Imagine um ciclista.

Ele pode sair apenas com a bicicleta.

Ou levar uma bomba de ar.

Kit de reparo.

Câmara reserva.

Pneu reserva.

Carro de apoio.

Mecânico.

Quanto maior a disponibilidade desejada, maior será o custo.

Em tecnologia ocorre exatamente o mesmo.

Alta disponibilidade.

Disaster Recovery.

Cyber Recovery.

Backups.

Replicação.

GDPS.

Sysplex.

Active-Active.

Tudo possui custo.

O objetivo não é atingir disponibilidade infinita.

O objetivo é encontrar equilíbrio entre risco, orçamento e necessidade do negócio.

O desenvolvedor COBOL de 2026

O profissional COBOL moderno não é apenas alguém que conhece MOVE, PERFORM e READ.

Ele entende Git.

Conhece APIs.

Aprende DevOps.

Sabe interpretar métricas.

Participa de revisões.

Automatiza testes.

Compreende observabilidade.

Conhece conceitos de segurança.

Entende resiliência.

Estuda Inteligência Artificial.

E principalmente, continua cultivando algo que sempre esteve presente no universo Mainframe:

Disciplina técnica.

Os sistemas que movimentam bilhões de transações diariamente não permanecem relevantes por acaso.

Eles permanecem relevantes porque existem profissionais dispostos a compreender o passado, melhorar continuamente o presente e testar constantemente o futuro.

E talvez seja exatamente essa a maior lição do Mainframe.

Tecnologia muda.

Ferramentas mudam.

Buzzwords mudam.

Mas excelência em engenharia continua sendo atemporal.

E isso, felizmente, nunca sai de moda.

Até o próximo café.

☕ Bellacosa Mainframe


Bellacosa Mainframe Network

Siga nossas newsletters e comunidades no LinkedIn

quinta-feira, 25 de dezembro de 2025

💥 SEU CICS NÃO QUEBROU — VOCÊ QUE NÃO ENTENDEU OS SINAIS

 

Bellacosa Mainframe solucionando problemas no CICS

💥 SEU CICS NÃO QUEBROU — VOCÊ QUE NÃO ENTENDEU OS SINAIS

O guia definitivo de troubleshooting CICS para dev COBOL sênior


Se você trabalha há anos com COBOL no CICS, já percebeu uma verdade incômoda:

CICS quase nunca “quebra do nada”. Ele avisa. Sempre.

O problema é que esses avisos vêm em forma de:

  • mensagens crípticas
  • sintomas indiretos
  • comportamento estranho

E aqui nasce a diferença entre:
👉 quem reage
👉 e quem diagnostica


🧠 ORIGEM: POR QUE CICS É ASSIM?

CICS nasceu nos anos 60/70 com um objetivo claro:

Alta disponibilidade + consistência transacional

Isso significa:

  • Não pode “tentar de novo e ver no que dá”
  • Não pode perder dados
  • Não pode assumir comportamento implícito

👉 Por isso:

💥 Se algo falha, ele PARA e registra — não improvisa


💣 FUNDAMENTO: SINTOMA ≠ CAUSA

Esse é o maior erro até de dev experiente.


🎯 Exemplo clássico:

Usuário:

“Sistema travou”


Possíveis causas:

  • Lock no IBM Db2
  • Loop de programa
  • Espera por recurso
  • Fila congestionada no IBM MQ

💡 Tradução:

O sintoma é genérico — o padrão é específico


🔍 O MAPA MENTAL DO TROUBLESHOOTING

Se você guardar só isso, já sobe de nível:

SintomaDiagnóstico provável
CPU altaLoop
CPU baixa + paradoWait
DFHACxxxxAbend
DFHSMxxxxStorage violation
IXGWRITELog problem
LentidãoPerformance

💥 OS 4 GRANDES CENÁRIOS (VIDA REAL)


🔁 1. LOOP — O DEVORADOR DE CPU

Sintomas:

  • CPU 100%
  • Sistema “busy”
  • Tasks não avançam

Causa comum:

PERFORM UNTIL WS-FIM = 'S'
* nunca muda WS-FIM 😈
END-PERFORM

💡 Easter egg 😏

AICA (abend de loop) é basicamente o CICS dizendo:
“chega, já deu…”



⏳ 2. WAIT — O SILÊNCIO PERIGOSO

Sintomas:

  • Sistema parado
  • CPU livre
  • Usuários esperando

Causa comum:

  • Lock no DB2
  • Arquivo VSAM ocupado

💡 Insight de produção:

WAIT não é erro — é dependência



💣 3. ABEND — O GRITO DO PROGRAMA

Clássicos:

CódigoSignificado
ASRAerro de programa
AEI0erro DB2
AEY9programa não encontrado

Exemplo real:

DFHAC2206 TRANS PAY1 ABEND ASRA

💡 Tradução:

  • Seu COBOL falhou
  • E deixou rastro


💥 4. STORAGE VIOLATION — O CAOS

DFHSM0102 Storage violation

👉 Isso significa:

Um programa sobrescreveu memória de outro


💡 Curiosidade histórica:
Isso vem da época onde controle de memória era mais “manual”
— e ainda hoje pode acontecer com ponteiros mal usados



🐢 PERFORMANCE — O INIMIGO INVISÍVEL

Performance ruim não derruba sistema…

👉 mas derruba o negócio


Sintomas:

  • Transações lentas
  • “CICS under stress”
  • Fila interna crescendo

Causas reais:

  • SQL ruim no DB2
  • MQ congestionado
  • Código ineficiente

💡 Easter egg 😏

“Está lento” quase nunca é CICS… quase sempre é SQL



🧾 LOG — A MEMÓRIA DO CICS

O CICS usa o MVS logger para armazenar:

  • System log
  • Forward recovery
  • Journals

👉 Se isso falhar:

IXGWRITE error

💥 Problema sério:

  • Sem log → sem recovery
  • Sem recovery → risco total

💡 Frase forte:

“Sem log, o CICS esquece o que aconteceu”



🔌 EXCI E COMUNICAÇÃO — OS FALSOS CULPADOS

Muitas vezes o erro NÃO está no CICS.


EXCI:

  • Batch chamando CICS
  • Integração interna

Comunicação:

  • TCP/IP
  • MRO
  • Sysplex

💡 Insight de campo:

Se parece problema de aplicação… desconfie da rede 😈



🧠 O PAPEL DO OPERADOR (E DO DEV ESPERTO)

Operador:

  • Identifica
  • Coleta
  • Escala

Dev sênior (você 😏):

  • Interpreta
  • Correlaciona
  • Resolve rápido

👉 Se o operador te entrega:

  • Transação
  • Hora
  • Mensagem

💥 Você já tem 70% do diagnóstico



🚀 PASSO A PASSO DE TROUBLESHOOTING (REAL)

🔍 1. Identifique o sintoma

  • CPU?
  • Espera?
  • Erro?

📊 2. Classifique

  • Loop
  • Wait
  • Abend
  • Performance

🧾 3. Leia a mensagem

👉 CICS SEMPRE fala o que aconteceu


🔎 4. Correlacione

  • DB2?
  • MQ?
  • VSAM?

⚙️ 5. Aja ou escale

  • Corrigir código
  • Ajustar recurso
  • Envolver sysprog


💣 CENÁRIO REAL (ESTILO BANCO)

Situação:

Sistema lento, sem erro


Dev iniciante:

“CICS está ruim”


Dev sênior:

  • Verifica tempo de resposta
  • Identifica SQL pesado
  • Ajusta query

🔥 Resultado:
Sistema normal



🧠 INSIGHT FINAL (NÍVEL EXPERT)

“CICS não falha em silêncio — ele deixa pistas.
Quem sabe ler, resolve rápido.
Quem não sabe… reinicia.”


🔥 CONCLUSÃO

Você não precisa decorar comandos.
Você precisa reconhecer padrões.


💥 Se você entendeu esse artigo, você já sabe:

✔ Diferenciar LOOP vs WAIT
✔ Ler mensagens DFH
✔ Entender abends
✔ Pensar como operador e dev


🚀 FRASE FINAL

“No mundo CICS, o problema nunca está escondido —
ele está escrito… você só precisa saber ler.”

 

sábado, 14 de dezembro de 2024

JSON em COBOL no IBM Z: O Holocron das APIs Modernas

 

Bellacosa Mainframe COBOL com JSON

JSON em COBOL no IBM Z: O Holocron das APIs Modernas

Como um Linguagem Criada em 1959 Aprendeu a Conversar com APIs, Mobile, Open Banking e a Nuvem

Por muitos anos, o universo COBOL parecia limitado a arquivos VSAM, DB2, IMS, CICS, JCLs e relatórios batch executados silenciosamente nos datacenters. Entretanto, a transformação digital trouxe novos desafios e uma nova linguagem passou a dominar a comunicação entre aplicações modernas: JSON (JavaScript Object Notation).

Hoje, smartphones, microsserviços, OpenShift, Open Banking, PIX, aplicações em nuvem e plataformas de inteligência artificial utilizam JSON como principal formato de intercâmbio de informações. E o mais interessante é que o Enterprise COBOL para IBM Z evoluiu para participar naturalmente desse ecossistema.

Com a introdução das instruções JSON PARSE e JSON GENERATE no Enterprise COBOL 6.x, programas COBOL passaram a compreender, produzir e consumir documentos JSON de forma nativa, eficiente e segura, permitindo a integração com APIs REST, IBM MQ, Kafka, z/OS Connect e arquiteturas modernas baseadas em eventos.

Esta série especial Bellacosa Mainframe apresenta uma jornada completa para o jovem Padawan COBOL compreender desde os conceitos básicos até técnicas avançadas utilizadas por especialistas IBM Z.


📖 Capítulo 1 – O Despertar do JSON

Quando o Padawan Descobre que COBOL Pode Falar a Linguagem das APIs

Neste primeiro holocron, exploramos os fundamentos do JSON, sua história, a chegada do suporte nativo ao Enterprise COBOL, diferenças entre JSON e XML, conceitos de UTF-8 e EBCDIC, além dos primeiros exemplos utilizando JSON GENERATE.

➡️ https://eljefemidnightlunch.blogspot.com/2024/07/json-em-cobol-no-ibm-z-o-holocron-das.html


📖 Capítulo 2 – JSON PARSE

Quando o Padawan Aprende a Transformar Texto em Estruturas COBOL

Aqui mergulhamos na instrução JSON PARSE, aprendendo a converter documentos JSON em estruturas COBOL, trabalhar com objetos aninhados, vetores utilizando OCCURS, tratar exceções, validar payloads recebidos e compreender os desafios relacionados à segurança e ao processamento de grandes volumes de dados.

➡️ https://eljefemidnightlunch.blogspot.com/2024/09/json-em-cobol-no-ibm-z-o-holocron-das.html


📖 Capítulo 3 – JSON GENERATE

Quando o Padawan Aprende a Construir APIs REST com COBOL

No terceiro capítulo, estudamos JSON GENERATE, recursos como SUPPRESS, NAME OF, tratamento de campos opcionais, construção de respostas para APIs REST, geração de payloads PIX e Open Banking, além de recomendações de desempenho e proteção contra exposição acidental de informações sensíveis.

➡️ https://eljefemidnightlunch.blogspot.com/2024/10/json-em-cobol-no-ibm-z-o-holocron-das.html


📖 Capítulo 4 – JSON Jedi Master

z/OS Connect, MQ, Kafka, OpenShift, OWASP e as Técnicas Jedi do IBM Z

No capítulo final, elevamos o nível de conhecimento para arquiteturas corporativas modernas. Exploramos o papel do z/OS Connect, integração com IBM MQ, Kafka, OpenShift, APIs de alto desempenho, conceitos da OWASP API Top 10, estratégias de observabilidade, segurança, escalabilidade e as melhores práticas adotadas por equipes especializadas em IBM Z.

➡️ https://eljefemidnightlunch.blogspot.com/2024/11/json-em-cobol-no-ibm-z-o-holocron-das.html


O Conselho Final do Mestre Bellacosa

Durante décadas, disseram aos desenvolvedores COBOL que sua missão terminava em arquivos sequenciais e terminais verdes. O JSON mostrou exatamente o contrário. Ele permitiu que programas escritos há décadas passassem a conversar com smartphones, microsserviços, aplicações em nuvem e plataformas digitais espalhadas por toda a galáxia tecnológica.

COBOL não precisou abandonar sua robustez, estabilidade ou capacidade de processar milhões de transações por segundo. Ele apenas aprendeu um novo idioma.

E talvez esta seja a maior lição deste Holocron:

COBOL não é uma tecnologia do passado.

COBOL é um veterano experiente que aprendeu a falar a língua do futuro.

Que o JSON PARSE esteja com você. E que o JSON GENERATE jamais exponha uma senha em produção. 🚀💙🖥️


Para ir mais longe

🔥☕ Como se Usa JSON em COBOL?

Nos últimos anos, o JSON (JavaScript Object Notation) tornou-se o formato mais utilizado para integração entre aplicações modernas, APIs REST, Mobile, Cloud e Mainframe.

https://eljefemidnightlunch.blogspot.com/2007/02/como-se-usa-json-em-cobol.html

🔥☕ JSON: O “COBOL DOS DADOS MODERNOS”? — A Linguagem Invisível Que Dominou APIs, Nuvem e Até o Mainframe

https://eljefemidnightlunch.blogspot.com/2010/10/json-o-cobol-dos-dados-modernos.html


sábado, 9 de novembro de 2024

JSON em COBOL no IBM Z: O Holocron das APIs Modernas – JSON Jedi Master - Parte IV

 

Bellacosa Mainframe e o json no cobol parte iv

JSON em COBOL no IBM Z: O Holocron das APIs Modernas

Parte 4 – JSON Jedi Master

z/OS Connect, MQ, Kafka, OpenShift, APIs de Alto Desempenho, Segurança OWASP e as Técnicas Jedi do IBM Z

Por Bellacosa Mainframe


"O Padawan aprende JSON PARSE. O Cavaleiro domina JSON GENERATE. O Mestre compreende que JSON é apenas a linguagem utilizada para conectar mundos inteiros."

Mestre Bellacosa Sysprog Jedi


Introdução

Chegamos ao último holocron.

Na Parte 1 aprendemos:

  • JSON

  • JSON GENERATE

  • UTF8

  • APIs

Na Parte 2:

  • JSON PARSE

  • Arrays

  • OCCURS

  • Segurança

Na Parte 3:

  • JSON GENERATE avançado

  • SUPPRESS

  • NAME OF

  • APIs REST

Agora chegamos ao nível do Mestre.

O momento em que COBOL deixa de apenas processar JSON.

E passa a ser um participante ativo de arquiteturas modernas.


O grande segredo

Muitos ainda imaginam.

COBOL

Batch

Relatório

Fim.

Mas o IBM Z moderno é muito diferente.

Hoje podemos encontrar:

COBOL

JSON

API

Mobile

Cloud

Kafka

OpenShift

IA

Aplicações Web


O papel do JSON

JSON tornou-se.

O idioma universal.


Imagine.

Banco.

Aplicativo.

PIX.

Open Finance.

Cartão.

Seguro.

Marketplace.

IoT.


Praticamente todos utilizam.

JSON.


z/OS Connect

Talvez seja a tecnologia mais importante.

Para o COBOL moderno.


O que é?

Uma ponte.

Entre.

IBM Z.

E.

REST APIs.


Visualmente.

Smartphone

↓

REST

↓

z/OS Connect

↓

COBOL

↓

DB2

Exemplo

Usuário.

Consulta saldo.

Aplicativo.

HTTPS

z/OS Connect

JSON

COBOL

DB2

JSON

Aplicativo


Tudo transparente.


COBOL não vê HTTP

Na maioria dos casos.

Não.


Ele apenas recebe.

Estrutura.

COBOL.

Já preenchida.


Exemplo.

01 WS-CONTA.


05 AGENCIA.


05 CONTA.



JSON PARSE.

Feito.

Automaticamente.


MQ

Outro caso.

Muito comum.


Mensagem.

Chega.

MQ.


Payload.

JSON.


COBOL.

Processa.


Exemplo.

{

"tipo":"pix",

"valor":100

}

COBOL.

Recebe.


Executa.

Negócio.


Responde.


JSON GENERATE.


MQPUT.


Fim.


Kafka

Sim.

Também.


Arquitetura.

COBOL

↓

MQ

↓

Kafka Bridge

↓

Kafka

↓

Analytics

Muito utilizado.


Open Finance.


Fraudes.


IA.


Big Data.


OpenShift

Outro mundo.

Interessante.


Microsserviços.

Containers.

Kubernetes.


COBOL.

Participa.


Arquitetura.

OpenShift

↓

REST

↓

zOS Connect

↓

COBOL

↓

IMS

DB2

Muito elegante.


APIs síncronas

Cliente.

Espera.

Resposta.


Exemplo.

Saldo.


API.

Responde.

200 ms.


APIs assíncronas

MQ.

Kafka.

Evento.


Mais modernas.


GraphQL

Também possível.


Embora.

Menos comum.


Segurança

Aqui começa.

O lado sombrio.


OWASP.

Existe.

Também.

Para APIs.


OWASP API Top 10

Excelente leitura.


Problemas.

Mais comuns.


Excesso.

Dados.


Exposição.

Sensível.


Autorização.

Fraca.


Payload.

Gigante.


DoS.


Exemplo ruim

COBOL.

01 CLIENTE.


05 CPF.


05 SENHA.


05 TOKEN.

JSON GENERATE.


API.


Exposta.


Desastre.


Melhor

Criar DTO.


Exemplo.

01 API-CLIENTE.


05 NOME.


05 LIMITE.

Muito melhor.


JWT

Muito utilizado.


JSON Web Token.


Aplicação.

Recebe.


Valida.


Autoriza.


COBOL.

Pode.

Consumir.


Ou.

Delegar.


TLS

Obrigatório.

Hoje.


HTTPS.

Sempre.


Nunca.

HTTP.


Rate Limit

Muito importante.


Evita.

DoS.


Exemplo.

Chamadas.

Por minuto.


Logs

Essenciais.


Exemplo.

2026-06-25


PIX


100 reais


OK

Muito útil.


Auditoria.


Performance

JSON.

Tem custo.


Parser.

CPU.


Serializer.

CPU.


Mas.

IBM Z.

É extremamente eficiente.


Benchmarks.

Mostram.

Milhares.

TPS.


Sem dificuldades.


JSON gigantesco

Cuidado.


Exemplo.

50 MB.


Parser.

Vai sofrer.


CPU.

Memória.


Melhor.

Paginar.


Streaming

Excelente opção.


Processar.

Em partes.


Mais eficiente.


Cache

Pode ajudar.


JSON.

Já montado.


Evita.

JSON GENERATE.

Toda vez.


Curiosidade

Muitos bancos.

Geram.

Milhões.

JSON.

Por hora.


E.

Grande parte.

Nasce.

Em COBOL.


Curiosidade 2

Usuário.

Abre.

App.


Consulta.

Saldo.


Recebe.

JSON.


Origem.

Programa COBOL.

Escrito.


Executando.

Num.

IBM z17.


Curiosidade 3

Muitos.

Open Banking.

Brasileiros.

Passam.

Por.

COBOL.

Sem.

Que.

Usuário.

Perceba.


Bellacosa Best Practices

Regra 1

Nunca.

Gerar.

JSON.

Com STRING.


Regra 2

JSON GENERATE.

Sempre.


Regra 3

JSON PARSE.

Sempre.


Regra 4

Versione.

APIs.


Exemplo.

v1

v2

v3


Regra 5

OpenAPI.

Swagger.

Documente.


Regra 6

Nunca.

Expor.

Campos internos.


Regra 7

Teste.

UTF8.


Regra 8

Monitore.

SMF.

RMF.

Logs.


Regra 9

Valide.

Payloads.


Regra 10

Use.

OWASP.

API Top 10.


Quando usar JSON?

Excelente.

REST.

Open Banking.

PIX.

Cloud.

Kafka.

MQ.

OpenShift.

Mobile.

Marketplace.

IoT.

Microsserviços.


Quando evitar?

Batch.

VSAM.

Arquivos internos.

Processamento.

Fechado.


O Conselho Final do Mestre Bellacosa

Durante muito tempo, disseram ao desenvolvedor COBOL que seu universo terminava em arquivos sequenciais, JCLs, relatórios impressos e terminais verdes.

JSON mostrou que isso nunca foi verdade.

JSON permitiu que programas escritos décadas atrás passassem a conversar com smartphones, aplicativos financeiros, plataformas Open Banking, clusters OpenShift, sistemas Kafka e serviços espalhados por diversas nuvens.

Talvez essa seja a maior beleza do IBM Z moderno.

Ele não obriga ninguém a abandonar o COBOL.

Ele apenas entrega novas ferramentas.

E diz:

Continue usando seus níveis 01, 05, 10 e OCCURS.

Continue confiando na robustez do Enterprise COBOL.

Continue processando milhões de transações por segundo.

Eu apenas ensinarei seu programa a falar o idioma utilizado pela galáxia digital.

E talvez essa seja a verdadeira lição do Holocron JSON.

JSON não substituiu COBOL.

JSON apenas permitiu que COBOL expandisse sua voz para além dos corredores do datacenter, alcançando praticamente qualquer sistema capaz de compreender uma simples mensagem cercada por chaves e aspas.


Fim do Holocron Bellacosa Mainframe

JSON em COBOL no IBM Z – Parte 1 a Parte 4 concluídas

"Que o JSON PARSE esteja com você. E que o JSON GENERATE nunca produza um campo SENHA por engano." 🚀💙🖥️


segunda-feira, 9 de setembro de 2024

Se você Saiu do Mainframe Há muito, mas muito tempo? Sherlock Holmes, COBOL e o Mistério da Plataforma que se Recusou a Envelhecer

 

Bellacosa Mainframe reapresenta o mainframe para antigos mainframers retornantes

☕ Um Café no Bellacosa Mainframe

Se você Saiu do Mainframe Há muito, mas muito tempo? Sherlock Holmes, COBOL e o Mistério da Plataforma que se Recusou a Envelhecer

Imagine a seguinte cena.

Depois de quinze ou vinte anos afastado do universo mainframe, você decide voltar.

Talvez tenha trabalhado com COBOL, JCL, CICS, VSAM ou DB2 no início dos anos 2000. Talvez tenha deixado a área para atuar com gestão, sistemas distribuídos, suporte, negócios ou até mesmo em outra profissão. Durante esse período, você acompanhou o nascimento da computação em nuvem, dos smartphones, das redes sociais, dos microsserviços, dos containers e da inteligência artificial.

Então surge a dúvida:

“Será que ainda sei alguma coisa útil?”

Você imagina entrar novamente em um ambiente mainframe e encontrar uma tecnologia completamente diferente daquela que conheceu. Talvez espere descobrir que o COBOL desapareceu, que o terminal 3270 virou peça de museu e que todos os sistemas foram substituídos por aplicativos modernos executando em alguma nuvem misteriosa.

Mas, ao atravessar a porta do data center, algo curioso acontece.

O cenário parece novo e familiar ao mesmo tempo.

É como Sherlock Holmes retornando a Baker Street depois de muitos anos. A cidade ganhou novos prédios, os carros mudaram, as comunicações ficaram instantâneas e agora existem câmeras por toda parte. Entretanto, os mistérios continuam sendo resolvidos da mesma forma: observando detalhes, seguindo pistas, eliminando hipóteses e compreendendo o comportamento humano.

No mainframe moderno, acontece algo parecido.

As ferramentas mudaram.

As integrações mudaram.

Os processos de desenvolvimento mudaram.

Porém, a essência do trabalho continua surpreendentemente reconhecível.

O primeiro mistério: o mainframe ficou parado no tempo?

Não.

Esse é o primeiro caso que precisamos solucionar.

O mainframe não ficou congelado em uma sala escura, cercado por fitas magnéticas e operadores usando jalecos brancos. Ele evoluiu continuamente.

O que aconteceu foi algo mais interessante: a plataforma evoluiu preservando compatibilidade com grande parte do que já existia.

Essa é uma das principais diferenças entre o mundo mainframe e muitas tecnologias distribuídas.

Em certos ecossistemas, uma nova versão pode tornar aplicações antigas incompatíveis. Frameworks surgem, ganham popularidade e desaparecem em poucos anos. Bibliotecas são abandonadas, padrões são substituídos e projetos inteiros precisam ser reescritos.

No mainframe, a evolução costuma ser mais cuidadosa.

A plataforma é responsável por sistemas bancários, seguradoras, governos, empresas de transporte, indústrias, companhias aéreas e organizações que não podem simplesmente parar tudo por alguns meses para reconstruir aplicações críticas.

Portanto, o mainframe evolui como uma grande cidade histórica.

Novas avenidas são construídas.

Novos sistemas de transporte são criados.

Novas redes de comunicação são instaladas.

Mas os prédios centrais continuam funcionando.

O COBOL continua presente.

O CICS continua processando transações.

O DB2 continua armazenando dados críticos.

O MQ continua transportando mensagens.

O JCL continua controlando processamento batch.

O JES continua recebendo e executando jobs.

O SDSF continua permitindo que o profissional consulte filas, resultados e mensagens.

E o TSO/ISPF continua lá, com suas telas, comandos e painéis familiares.

Quem retorna depois de muitos anos pode até sentir uma estranha sensação de conforto ao abrir o ISPF e perceber que a opção 3.2 continua sendo utilizada para trabalhar com data sets.

É quase como reencontrar um antigo café que mudou as mesas, reformou a fachada e instalou Wi-Fi, mas continua servindo o mesmo bom espresso.

O segundo mistério: o COBOL mudou completamente?

Para um programador COBOL iniciante, essa pergunta é importante.

A resposta é: o COBOL mudou, mas não perdeu sua identidade.

Quem conhecia a linguagem há quinze ou vinte anos ainda reconhecerá sua estrutura principal.

Um programa COBOL moderno continua podendo apresentar divisões como:

IDENTIFICATION DIVISION.
ENVIRONMENT DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.

Ainda encontraremos comandos como:

MOVE
IF
EVALUATE
PERFORM
READ
WRITE
REWRITE
DELETE
CALL

Ainda teremos variáveis descritas por níveis:

01 WS-CLIENTE.
   05 WS-CODIGO        PIC 9(08).
   05 WS-NOME          PIC X(40).
   05 WS-SALDO         PIC S9(11)V99 COMP-3.

Ainda haverá programas que acessam DB2:

EXEC SQL
   SELECT NOME,
          SALDO
     INTO :WS-NOME,
          :WS-SALDO
     FROM CLIENTES
    WHERE CODIGO = :WS-CODIGO
END-EXEC.

Ainda existirão programas CICS:

EXEC CICS
   READ FILE('CLIENTES')
        INTO(WS-REGISTRO)
        RIDFLD(WS-CODIGO)
        RESP(WS-RESP)
END-EXEC.

O programador que já conhecia COBOL não precisará reaprender a lógica fundamental da linguagem.

Porém, encontrará compiladores mais modernos, novos recursos, integração com JSON, XML, Unicode, APIs, ferramentas de análise, IDEs gráficas, testes automatizados e pipelines de desenvolvimento.

O COBOL não virou outra linguagem.

Ele ficou mais conectado ao mundo ao seu redor.

Uma analogia para o iniciante

Imagine um automóvel clássico que recebeu:

  • freios modernos;

  • injeção eletrônica;

  • sensores;

  • GPS;

  • computador de bordo;

  • novos sistemas de segurança.

O volante continua sendo um volante.

O motor continua transformando energia em movimento.

O motorista ainda precisa conhecer trânsito, direção, frenagem e manutenção.

Da mesma forma, o programador COBOL ainda precisa dominar:

  • estruturas de dados;

  • lógica condicional;

  • repetição;

  • arquivos;

  • bancos de dados;

  • tratamento de erros;

  • regras de negócio;

  • processamento transacional;

  • processamento batch.

As novas ferramentas ajudam, mas não substituem a compreensão.

O verdadeiro salto aconteceu ao redor do mainframe

Aqui encontramos a pista mais importante de toda a investigação.

Há quinze ou vinte anos, muitas aplicações mainframe eram acessadas diretamente por terminais 3270.

Um fluxo comum poderia ser representado assim:

Usuário
   ↓
Terminal 3270
   ↓
CICS
   ↓
Programa COBOL
   ↓
VSAM ou DB2

Esse modelo ainda existe.

Entretanto, hoje um mesmo programa pode participar de uma arquitetura muito mais ampla:

Aplicativo de celular
   ↓
API Gateway
   ↓
Microsserviço
   ↓
z/OS Connect
   ↓
CICS
   ↓
Programa COBOL
   ↓
DB2
   ↓
MQ
   ↓
Outro sistema corporativo

Observe o detalhe, meu caro Watson.

O aplicativo móvel pode ter sido escrito em Kotlin ou Swift.

A API pode utilizar Java, Node.js ou outra tecnologia.

A aplicação pode estar parcialmente executando em cloud ou em containers.

Mas a regra crítica de negócio pode continuar dentro de um programa COBOL que existe há décadas.

Isso não significa atraso.

Significa reutilização de um ativo confiável.

Se um programa calcula corretamente juros, impostos, limites, tarifas, seguros ou benefícios há vinte anos, talvez seja mais seguro integrá-lo a novas interfaces do que reescrever tudo apenas para seguir uma moda tecnológica.

O mainframe deixou de ser uma ilha

Antigamente, era comum imaginar o mainframe como uma grande fortaleza.

Tudo acontecia dentro dela.

Os usuários acessavam terminais.

Os sistemas trocavam arquivos.

Os jobs eram executados em horários definidos.

Grande parte da integração permanecia dentro dos limites da empresa.

Hoje, o mainframe faz parte de um ecossistema híbrido.

Ele pode conversar com:

  • aplicações web;

  • sistemas em cloud;

  • APIs REST;

  • ferramentas de analytics;

  • plataformas de inteligência artificial;

  • sistemas distribuídos;

  • aplicações móveis;

  • microsserviços;

  • ambientes Linux;

  • filas de mensagens;

  • plataformas de automação.

O mainframe não desapareceu.

Ele deixou de trabalhar sozinho.

CICS: do terminal 3270 para a API

Para o programador COBOL iniciante, é importante entender o papel do CICS.

CICS é um monitor de processamento transacional.

Ele permite que milhares de usuários e aplicações executem transações com rapidez, controle e segurança.

No passado, muitas transações CICS eram iniciadas diretamente por uma tela 3270.

O usuário digitava dados, pressionava Enter e o programa COBOL era executado.

Hoje, a mesma lógica pode ser acionada por uma API.

Por exemplo:

  1. Um cliente abre o aplicativo do banco.

  2. Solicita o saldo.

  3. O aplicativo envia uma requisição HTTPS.

  4. Uma API recebe essa solicitação.

  5. A API chama um serviço exposto pelo z/OS Connect.

  6. O serviço aciona uma transação ou programa no CICS.

  7. O programa COBOL consulta o DB2.

  8. O resultado é convertido para JSON.

  9. O aplicativo exibe o saldo ao usuário.

Para o cliente, tudo aconteceu em segundos.

Para o programa COBOL, talvez a operação continue sendo uma consulta conhecida há muitos anos.

A entrada mudou.

A saída mudou.

A regra central permaneceu.

DB2, VSAM e o valor dos dados

Todo bom detetive sabe que uma pista isolada não resolve um caso.

É preciso saber onde ela está armazenada e como se relaciona com outras informações.

No mainframe, grande parte das pistas está nos dados.

O DB2 continua sendo um dos pilares de inúmeros sistemas corporativos. Ele oferece recursos de banco de dados relacional, controle transacional, concorrência, integridade e recuperação.

O VSAM também continua presente, especialmente em aplicações que utilizam arquivos estruturados de alta performance.

Um programador COBOL iniciante deve compreender pelo menos quatro conceitos básicos:

1. KSDS

O Key Sequenced Data Set organiza registros por chave.

É semelhante à ideia de acessar um cadastro por um código identificador.

2. ESDS

O Entry Sequenced Data Set armazena registros na ordem em que foram incluídos.

3. RRDS

O Relative Record Data Set permite acessar registros por número relativo.

4. LDS

O Linear Data Set é utilizado como estrutura de armazenamento de baixo nível por alguns produtos.

Mesmo com bancos modernos, APIs e cloud, esses conceitos continuam importantes porque muitos sistemas críticos dependem deles.

MQ: o mensageiro silencioso

Imagine que Sherlock Holmes precisa enviar uma mensagem confidencial para o inspetor Lestrade.

Ele poderia entregar pessoalmente.

Mas também poderia utilizar um mensageiro confiável, garantindo que a mensagem chegasse ao destino mesmo que Lestrade não estivesse disponível naquele instante.

O MQ desempenha papel semelhante.

Uma aplicação envia uma mensagem para uma fila.

Outra aplicação consome essa mensagem quando estiver pronta.

Isso permite desacoplar sistemas.

Por exemplo:

Programa COBOL
   ↓
Fila MQ
   ↓
Sistema antifraude
   ↓
Fila de resposta
   ↓
Outro programa

O produtor da mensagem não precisa conhecer todos os detalhes do consumidor.

Ele precisa apenas respeitar o formato combinado.

Essa arquitetura ajuda a integrar mainframe, cloud, sistemas distribuídos e aplicações externas.

O batch não morreu

Existe uma espécie de lenda urbana na tecnologia: a ideia de que tudo precisa acontecer online e em tempo real.

Não é verdade.

Muitas tarefas continuam sendo mais eficientes em processamento batch.

Entre elas:

  • fechamento contábil;

  • geração de extratos;

  • cálculo de folha de pagamento;

  • faturamento;

  • conciliação;

  • processamento de grandes volumes;

  • cálculo de impostos;

  • liquidação financeira;

  • atualização de cadastros;

  • geração de relatórios.

Um job JCL pode executar vários programas em sequência:

//FECHAMTO JOB ...
//STEP01   EXEC PGM=VALIDA
//ENTRADA  DD DSN=EMPRESA.ARQUIVO.ENTRADA,DISP=SHR
//SAIDA    DD DSN=EMPRESA.ARQUIVO.VALIDADO,
//            DISP=(NEW,CATLG,DELETE)
//STEP02   EXEC PGM=CALCULA
//STEP03   EXEC PGM=ATUALIZA

O princípio continua familiar.

Cada etapa realiza uma parte do trabalho.

O resultado de uma etapa pode alimentar a próxima.

O JES controla a execução.

As mensagens podem ser analisadas pelo SDSF.

O programador ainda precisa investigar códigos de retorno, abends, arquivos, condições e dependências.

Sherlock Holmes entra no SDSF

Suponha que um job terminou com erro.

O iniciante pode olhar para a tela e pensar:

“O programa quebrou.”

O analista experiente pensa diferente.

Ele pergunta:

  • Qual step falhou?

  • Qual foi o código de retorno?

  • Houve abend?

  • O arquivo existia?

  • O DISP estava correto?

  • O espaço foi suficiente?

  • O programa encontrou o registro esperado?

  • O SQLCODE indica erro de banco?

  • O problema aconteceu antes ou depois da alteração?

  • Qual mensagem apareceu primeiro?

Essa é a mentalidade investigativa.

Um erro observado no final nem sempre começou no final.

Talvez o STEP03 tenha falhado porque o STEP02 gerou um arquivo vazio.

Talvez o STEP02 tenha gerado um arquivo vazio porque o STEP01 utilizou uma data incorreta.

Talvez a data incorreta tenha sido enviada por um sistema externo.

O verdadeiro culpado pode estar muitos passos antes da mensagem final.

Elementar.

Git, DevOps e pipelines

Uma das maiores mudanças para quem retorna ao mainframe está no processo de desenvolvimento.

No modelo tradicional, o código COBOL podia permanecer em bibliotecas PDS ou PDSE, controlado por ferramentas corporativas de gerenciamento de mudanças.

Hoje, muitas empresas integram o mainframe com Git.

Isso permite trabalhar com conceitos como:

  • repositório;

  • branch;

  • commit;

  • merge;

  • pull request;

  • code review;

  • pipeline;

  • integração contínua;

  • entrega contínua.

Um fluxo moderno pode ser:

Desenvolvedor altera o COBOL
   ↓
Cria um commit
   ↓
Envia para o Git
   ↓
Pipeline inicia
   ↓
Código é compilado
   ↓
Testes são executados
   ↓
Qualidade é verificada
   ↓
Artefatos são preparados
   ↓
Implantação segue para o ambiente correto

O programa COBOL continua sendo COBOL.

O que mudou foi a estrada utilizada para levá-lo do desenvolvimento até a produção.

DevOps não é uma ferramenta

Essa distinção é importante.

DevOps não é apenas Jenkins.

Não é apenas Git.

Não é apenas pipeline.

DevOps é uma forma de organizar pessoas, processos e tecnologia para entregar software com maior frequência, segurança e rastreabilidade.

No contexto mainframe, isso pode envolver:

  • versionamento de código;

  • automação de builds;

  • testes automatizados;

  • análise de qualidade;

  • controle de mudanças;

  • infraestrutura como código;

  • observabilidade;

  • colaboração entre desenvolvimento e operação.

Para quem está retornando, não é necessário aprender tudo de uma vez.

O importante é compreender o fluxo.

Passo a passo para quem deseja voltar ao mainframe

Agora chegamos à parte prática da investigação.

Passo 1: recupere os fundamentos

Revise:

  • estrutura de programas COBOL;

  • PIC;

  • níveis de dados;

  • COMP e COMP-3;

  • tabelas;

  • REDEFINES;

  • PERFORM;

  • EVALUATE;

  • arquivos;

  • subprogramas;

  • tratamento de erros.

Não tente começar pelas ferramentas mais modernas sem recuperar a base.

Passo 2: revise JCL

Estude:

  • JOB;

  • EXEC;

  • DD;

  • DISP;

  • DSN;

  • SPACE;

  • DCB;

  • COND;

  • IF/THEN/ELSE;

  • PROC;

  • parâmetros simbólicos;

  • GDG;

  • utilitários.

O JCL continua sendo essencial para o processamento batch.

Passo 3: volte ao TSO/ISPF e SDSF

Relembre:

  • navegação no ISPF;

  • edição de membros;

  • manipulação de data sets;

  • submissão de jobs;

  • consulta de spool;

  • interpretação de mensagens;

  • análise de códigos de retorno.

Passo 4: escolha uma trilha de banco ou arquivo

Você pode aprofundar:

  • DB2 e SQL;

  • VSAM;

  • IMS DB.

Para muitos profissionais, DB2 é um excelente ponto de partida.

Passo 5: estude CICS

Compreenda:

  • transação;

  • programa;

  • COMMAREA;

  • canais e containers;

  • mapas BMS;

  • LINK;

  • XCTL;

  • START;

  • READ;

  • WRITE;

  • REWRITE;

  • DELETE;

  • códigos RESP.

Passo 6: aprenda integração moderna

Estude os conceitos de:

  • API REST;

  • JSON;

  • HTTP;

  • z/OS Connect;

  • MQ;

  • autenticação;

  • microsserviços.

Não é necessário virar especialista em desenvolvimento web.

É necessário entender como o COBOL participa do fluxo.

Passo 7: entre no mundo Git

Pratique:

git clone
git checkout -b
git add
git commit
git push
git pull

Entenda a lógica de branches e pull requests.

Passo 8: conheça pipelines

Aprenda o conceito antes da ferramenta.

Pergunte:

  • O que inicia o pipeline?

  • Como o código é compilado?

  • Onde os testes executam?

  • Como o artefato é promovido?

  • Quem aprova a mudança?

  • Como ocorre o rollback?

Passo 9: use inteligência artificial como assistente

A IA pode ajudar a:

  • explicar um trecho COBOL;

  • documentar código;

  • sugerir casos de teste;

  • analisar mensagens de erro;

  • criar exemplos;

  • comparar comandos;

  • explicar JCL;

  • revisar SQL.

Mas existe uma regra de ouro:

Nunca aceite uma resposta técnica sem validar contexto, sintaxe, impacto e segurança.

A IA é Watson.

Você continua sendo Sherlock Holmes.

A experiência ainda vale?

Vale muito.

Talvez mais do que antes.

Um profissional experiente sabe que alterar uma linha de código pode afetar:

  • outro programa;

  • outro job;

  • outro arquivo;

  • uma interface;

  • um relatório;

  • uma regra fiscal;

  • uma rotina contábil;

  • um processo noturno;

  • um sistema externo;

  • uma operação de negócio.

Essa percepção não nasce apenas em cursos.

Ela nasce de incidentes, projetos, viradas de produção, abends, reuniões, erros, acertos e noites acompanhando processamento.

O conhecimento técnico pode ser atualizado.

A maturidade sistêmica leva tempo para ser construída.

Curiosidade: por que o mainframe sobreviveu?

Porque ele resolve problemas difíceis.

Entre suas características estão:

  • alta disponibilidade;

  • segurança;

  • escalabilidade;

  • processamento transacional;

  • grande capacidade de entrada e saída;

  • gestão de cargas;

  • confiabilidade;

  • compatibilidade;

  • recuperação;

  • governança.

Empresas não mantêm mainframes por nostalgia.

Mantêm porque substituir sistemas críticos é caro, arriscado e complexo.

Além disso, a plataforma continua evoluindo.

Easter egg: o programa que ninguém queria tocar

Em quase toda grande empresa existe um programa lendário.

Ele possui milhares de linhas.

Foi escrito por alguém que se aposentou.

Tem comentários misteriosos.

Contém parágrafos chamados:

9000-ROTINA-ESPECIAL.

Ninguém sabe exatamente por que a rotina é especial.

Dentro dela há uma condição:

IF WS-CODIGO = 37
   MOVE 'S' TO WS-LIBERA
END-IF.

Todos perguntam:

“Por que 37?”

A documentação não explica.

O analista antigo diz:

“Não mexa nisso. Foi criado depois do incidente de 1998.”

Esse é o verdadeiro folclore mainframe.

Mas também revela um problema sério: conhecimento não documentado.

O profissional moderno deve preservar a confiabilidade do legado, mas também melhorar documentação, testes e rastreabilidade.

Dicas para o programador COBOL iniciante

Primeira dica: não tenha vergonha de perguntar.

Mainframe é um ecossistema enorme. Ninguém domina tudo.

Segunda dica: aprenda a ler antes de querer escrever.

Grande parte do trabalho será compreender programas existentes.

Terceira dica: siga os dados.

Quando estiver investigando um problema, acompanhe:

  • entrada;

  • transformação;

  • armazenamento;

  • saída.

Quarta dica: leia as mensagens completas.

Não olhe apenas para a última linha do erro.

Quinta dica: entenda o negócio.

Um programa não existe por causa da tecnologia. Ele existe para cumprir uma regra.

Sexta dica: evite alterações desnecessárias.

Em sistemas críticos, elegância não vale mais do que previsibilidade.

Sétima dica: teste cenários extremos.

Considere:

  • zeros;

  • valores negativos;

  • campos vazios;

  • datas inválidas;

  • duplicidade;

  • arquivo inexistente;

  • registro não encontrado;

  • SQLCODE inesperado;

  • indisponibilidade de serviço.

Oitava dica: documente o motivo.

O código mostra o que foi feito.

O comentário deve explicar por que foi feito.

O retorno não é um recomeço do zero

Quem saiu do mainframe há quinze anos não retorna como iniciante absoluto.

Retorna como alguém que já conhece parte do mapa.

Será necessário atualizar ferramentas, processos e integrações.

Mas a capacidade de analisar sistemas, compreender regras e trabalhar com responsabilidade continua presente.

Talvez você precise aprender Git.

Talvez precise entender APIs.

Talvez precise utilizar VS Code.

Talvez precise estudar pipelines.

Mas ainda reconhecerá o cheiro de um job em produção, o silêncio desconfortável de um código de retorno inesperado e a satisfação de encontrar a causa de um erro escondida em uma variável inicializada incorretamente.

Conclusão: o último mistério de Baker Street

Sherlock Holmes colocaria todas as pistas sobre a mesa:

  • o COBOL continua vivo;

  • o CICS continua processando transações;

  • o DB2 continua armazenando dados críticos;

  • o batch continua movimentando empresas;

  • o JCL continua organizando execuções;

  • o mainframe agora conversa com APIs, cloud e aplicações móveis;

  • Git e DevOps modernizaram o processo;

  • a inteligência artificial acelerou o aprendizado;

  • a experiência continua sendo um ativo valioso.

Então ele concluiria:

“O mainframe não permaneceu no passado. Ele trouxe o passado consigo, incorporou o presente e continua se preparando para o futuro.”

Para o programador COBOL iniciante, essa é uma excelente notícia.

Você está entrando em um ambiente que valoriza fundamentos.

Para o profissional que deseja retornar, a notícia é ainda melhor.

Você não perdeu tudo o que sabia.

Seu conhecimento apenas precisa ser recompilado com novas opções, testado em um novo pipeline e integrado a um ecossistema mais moderno.

No Bellacosa Mainframe, diríamos que a carreira não sofreu um ABEND definitivo.

Ela apenas ficou aguardando um novo EXEC.

E quando esse momento chegar, talvez você descubra que a plataforma mudou bastante ao redor de você, mas ainda reconhece perfeitamente os caminhos internos do sistema.

Afinal, meu caro Watson, tecnologias podem mudar de interface.

Mas bons profissionais continuam seguindo pistas, protegendo dados, compreendendo negócios e mantendo o mundo funcionando enquanto todos dormem.

Um Café no Bellacosa Mainframe — onde cada SYSOUT conta uma história, cada ABEND esconde um mistério e todo programa COBOL antigo pode guardar uma pista sobre o futuro.

 

Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...