Translate

terça-feira, 21 de abril de 2026

AI Chatbots, AI Agents e Multi-Agent Systems O Que Todo Programador COBOL Padawan Precisa Saber Sobre a Próxima Revolução da Engenharia de Software

 

Bellacosa Mainframe AI chatbos agents e multi-agents systems

☕ Um Café no Bellacosa Mainframe

AI Chatbots, AI Agents e Multi-Agent Systems

O Que Todo Programador COBOL Padawan Precisa Saber Sobre a Próxima Revolução da Engenharia de Software

"Você não está apenas aprendendo Inteligência Artificial. Está descobrindo como os sistemas do futuro serão construídos — e, curiosamente, como eles se parecem muito mais com um IBM Mainframe do que a maioria das pessoas imagina."

Durante muitos anos ouvimos que a Inteligência Artificial substituiria programadores, escreveria software sozinha e transformaria completamente a indústria. Grande parte dessas previsões eram exageradas. O que realmente está acontecendo é muito mais interessante.

A verdadeira revolução não está em criar uma IA que saiba fazer tudo.

Ela está em criar equipes de inteligências artificiais, cada uma especializada em uma função específica, trabalhando em conjunto exatamente como acontece em uma empresa ou, para nossa surpresa, exatamente como acontece dentro de um ambiente IBM z/OS.

Se você é um Programador COBOL Padawan, este é um daqueles momentos em que compreender um conceito novo pode mudar completamente sua maneira de enxergar a tecnologia.

E a boa notícia?

Você já conhece, sem perceber, muitos dos princípios que sustentam essa nova geração de IA.


A primeira ilusão da Inteligência Artificial

Quando o ChatGPT surgiu, muita gente imaginou que havia nascido um cérebro artificial.

Parecia existir uma única inteligência capaz de responder qualquer pergunta.

Na realidade, um chatbot tradicional funciona de maneira relativamente simples.

O fluxo costuma ser:

Usuário

↓

Prompt

↓

LLM

↓

Resposta

O usuário faz uma pergunta.

O modelo analisa os tokens.

Prediz a sequência mais provável.

Entrega uma resposta.

Fim.

Não existe uma equipe trabalhando.

Não existe divisão de tarefas.

Não existe planejamento complexo.

É uma conversa extremamente sofisticada, mas ainda assim linear.


O chatbot é um excelente especialista... mas continua sozinho

Imagine que você pergunte:

"Explique como funciona um arquivo VSAM KSDS."

O chatbot responde.

Agora pergunte:

"Escreva um programa COBOL utilizando CICS, DB2, MQ, autenticação RACF, documentação técnica, casos de teste, scripts DevOps e um pipeline CI/CD."

Ele tentará fazer tudo.

Mas existe um problema.

Está tentando atuar simultaneamente como:

  • Analista de Sistemas

  • Arquiteto

  • DBA

  • Programador COBOL

  • Especialista CICS

  • Especialista MQ

  • Especialista em Segurança

  • Analista de Testes

  • Redator Técnico

  • DevOps

Nenhum profissional faz tudo isso perfeitamente.

Nem um modelo de IA.


Imagine uma empresa com apenas um funcionário

Vamos fazer uma analogia.

Imagine abrir um banco.

Você contrata apenas uma pessoa.

Ela deverá ser:

  • Presidente

  • Caixa

  • Segurança

  • Auditor

  • Contador

  • Analista de Crédito

  • Atendimento

  • TI

  • Limpeza

Parece absurdo.

Mas foi exatamente assim que imaginamos a Inteligência Artificial durante algum tempo.

Uma única IA faria absolutamente tudo.

O problema é que especialização sempre vence generalização quando o assunto é trabalho complexo.


É aqui que nascem os AI Agents

Agora imagine outro cenário.

Você continua tendo uma IA extremamente inteligente.

Mas ela aprende uma habilidade nova.

Ela não apenas responde.

Ela começa a agir.

Ela consegue:

  • planejar

  • pesquisar

  • acessar APIs

  • consultar bancos de dados

  • executar programas

  • validar resultados

  • corrigir erros

  • tentar novamente

Ela passa a perseguir objetivos.

Isso muda completamente o jogo.


Um agente pensa em etapas

Vamos imaginar um pedido simples.

"Analise o desempenho do meu banco DB2."

Um chatbot responderia algo como:

"Verifique índices, RUNSTATS, REORG..."

Um AI Agent faria algo diferente.

Ele poderia executar automaticamente um fluxo como este:

Receber objetivo

↓

Conectar ao catálogo DB2

↓

Ler estatísticas

↓

Analisar índices

↓

Verificar tabelas fragmentadas

↓

Comparar histórico

↓

Gerar relatório

↓

Sugerir melhorias

Observe a diferença.

Ele deixou de responder.

Agora ele trabalha.


O cérebro continua sendo um LLM

Muitas pessoas imaginam que um AI Agent seja um modelo completamente diferente.

Não é.

O cérebro continua sendo um Large Language Model.

A diferença é que agora existe uma arquitetura em volta dele.

Ela adiciona capacidades como:

  • memória

  • ferramentas

  • planejamento

  • execução

  • observação

  • replanejamento

É como instalar diversos periféricos em um computador.

O processador continua sendo o mesmo.

Mas agora ele possui discos, rede, impressoras e dispositivos externos.


Um agente utiliza ferramentas

Pense em você.

Você não resolve tudo apenas pensando.

Você utiliza ferramentas.

No Mainframe você usa:

  • ISPF

  • SDSF

  • TSO

  • DB2 SPUFI

  • File Manager

  • Fault Analyzer

  • Abend-AID

Da mesma forma, um agente utiliza ferramentas digitais.

Ele pode chamar:

  • APIs REST

  • Bancos SQL

  • Python

  • Shell Script

  • GitHub

  • Docker

  • Navegadores

  • Serviços MCP (Model Context Protocol)

O LLM passa a ser apenas o cérebro que decide qual ferramenta utilizar.


Mas a verdadeira revolução ainda estava por vir

Mesmo um agente possui limitações.

Imagine pedir:

"Modernize um sistema COBOL com oito milhões de linhas."

É uma tarefa gigantesca.

Existe muito trabalho.

Então surge uma pergunta natural.

Por que colocar tudo nas costas de um único agente?

Por que não criar uma equipe?

Nasce então o conceito de Multi-Agent Systems.


Bem-vindo ao escritório da Inteligência Artificial

Agora imagine um escritório.

Em vez de uma única IA...

Existem várias.

Cada uma extremamente especializada.

             Orquestrador

      ↓       ↓       ↓

 COBOL     DB2      CICS

      ↓       ↓       ↓

 Segurança   Testes   APIs

             ↓

      Documentação

Pela primeira vez, a IA começa a funcionar como uma empresa.


O papel do Orquestrador

Toda equipe precisa de alguém coordenando.

Na arquitetura Multi-Agent existe normalmente um componente chamado Orchestrator.

Ele funciona como um gerente de projetos.

Recebe um objetivo.

Analisa.

Divide.

Distribui.

Depois reúne os resultados.

Seu trabalho não é escrever código.

Seu trabalho é organizar pessoas...

Ou melhor...

Organizar agentes.


Parece familiar?

Se você trabalha com Mainframe, provavelmente sim.

Veja alguns componentes do z/OS.

  • JES2

  • RACF

  • DB2

  • IMS

  • CICS

  • MQ

  • DFSMS

  • WLM

Nenhum deles faz tudo.

Cada um possui responsabilidades muito claras.

O sistema operacional coordena todos.

Curiosamente, a arquitetura Multi-Agent segue exatamente essa filosofia.


IBM já fazia isso há décadas

Muita gente acredita que Multi-Agent Systems são uma invenção recente.

Na prática, a computação corporativa utiliza esse conceito desde os anos 70.

Pense em uma transação bancária.

Quando um cliente faz um PIX ou consulta saldo, vários subsistemas trabalham em conjunto:

  • CICS recebe a requisição.

  • RACF autentica o usuário.

  • DB2 consulta os dados.

  • MQ envia mensagens para outros sistemas.

  • JES2 agenda tarefas em batch.

  • WLM distribui recursos de CPU.

  • DFSMS gerencia armazenamento.

Nenhum desses componentes conhece todo o sistema.

Cada um é especialista em sua área.

Essa divisão de responsabilidades é um dos pilares da escalabilidade do IBM Z.

Os sistemas multiagentes apenas transportam essa filosofia para o universo da IA.


Um exemplo para um Programador COBOL Padawan

Imagine que um banco deseje transformar um sistema legado em APIs REST.

Um ambiente multiagente poderia funcionar assim:

Agente 1 — Descoberta

Analisa milhões de linhas COBOL.

Identifica programas.

Mapeia COPYBOOKs.


Agente 2 — Banco de Dados

Localiza tabelas DB2.

Descobre relacionamentos.

Analisa índices.


Agente 3 — CICS

Detecta transações.

Analisa COMMAREAs.

Mapeia Channels e Containers.


Agente 4 — Documentação

Produz diagramas.

Cria documentação técnica.

Explica regras de negócio.


Agente 5 — APIs

Transforma programas em serviços REST.

Gera especificações OpenAPI.


Agente 6 — Testes

Cria testes unitários.

Executa validações.

Produz cobertura de testes.


Agente 7 — Segurança

Analisa autenticação.

Detecta vulnerabilidades.

Sugere melhorias.


Observe que ninguém faz tudo.

Cada agente faz apenas aquilo em que é especialista.


O conceito de Inteligência Coletiva

Um dos maiores erros ao estudar IA é imaginar inteligência como algo individual.

Na natureza, muitos organismos demonstram inteligência coletiva.

Formigas.

Abelhas.

Cupins.

Cardumes.

Nenhum indivíduo conhece o plano completo.

Mesmo assim, a colônia produz comportamentos extraordinários.

Os sistemas multiagentes seguem esse princípio.

Cada agente possui conhecimento limitado.

Mas o conjunto resolve problemas extremamente complexos.


Comunicação entre agentes

Surge então outro desafio.

Como essas inteligências conversam?

A resposta depende da arquitetura.

Algumas utilizam mensagens JSON.

Outras empregam filas como Apache Kafka ou RabbitMQ.

Há ainda sistemas baseados em eventos, chamadas REST e protocolos emergentes como o Model Context Protocol (MCP), que facilita o compartilhamento de contexto e ferramentas entre modelos.

Essa comunicação precisa ser eficiente, confiável e segura.

Caso contrário, os agentes passam mais tempo trocando informações do que resolvendo problemas.


Quando os agentes discordam

Outro aspecto fascinante é que agentes podem divergir.

Imagine três especialistas analisando uma consulta SQL.

O primeiro sugere criar um índice.

O segundo afirma que uma reorganização resolveria o problema.

O terceiro recomenda alterar o plano de acesso.

Quem está certo?

Em sistemas avançados, outro agente pode atuar como árbitro, comparar evidências, executar testes e escolher a melhor solução.

Esse mecanismo reduz vieses e melhora a qualidade das decisões.


Mais agentes significam mais inteligência?

Nem sempre.

Adicionar agentes indiscriminadamente pode gerar:

  • custos maiores com tokens;

  • aumento da latência;

  • conflitos de decisão;

  • duplicação de trabalho;

  • dificuldade de coordenação.

Assim como uma empresa com funcionários demais pode se tornar burocrática, um sistema multiagente mal projetado pode ser menos eficiente do que um único agente bem configurado.

Arquitetura continua sendo essencial.


O futuro do desenvolvimento de software

Imagine abrir seu ambiente de desenvolvimento daqui a alguns anos.

Você descreve uma funcionalidade:

"Criar um novo módulo de empréstimos."

Imediatamente, um orquestrador distribui tarefas:

  • um agente conversa com os analistas de requisitos;

  • outro gera o modelo de dados;

  • um terceiro escreve programas COBOL;

  • outro prepara JCLs;

  • um agente cria testes automatizados;

  • outro verifica segurança;

  • outro produz documentação;

  • um último acompanha a implantação.

Você deixa de trabalhar sozinho com uma IA e passa a liderar uma equipe digital de especialistas.

O desenvolvedor torna-se um arquiteto e coordenador, capaz de definir objetivos, validar resultados e integrar soluções.


O Programador COBOL Padawan não está ficando para trás

Existe um mito de que apenas quem desenvolve aplicações em linguagens modernas participará dessa transformação.

Nada poderia estar mais distante da realidade.

Os maiores bancos, seguradoras, empresas aéreas e governos do mundo continuam executando processos críticos em IBM Z. São ambientes ricos em regras de negócio, documentação histórica e sistemas integrados — exatamente o tipo de contexto em que agentes especializados podem gerar enorme valor.

Conhecer COBOL, CICS, JCL, DB2, VSAM e arquitetura de sistemas corporativos passa a ser um diferencial estratégico, porque esses agentes precisam de especialistas humanos para orientar sua evolução, validar decisões e definir políticas de governança.


Uma nova trilha de conhecimento

Se você deseja se preparar para essa nova era, considere construir uma trilha de aprendizado como esta:

  1. Domine os fundamentos de algoritmos e estruturas de dados.

  2. Aprofunde seus conhecimentos em COBOL, JCL, CICS e DB2.

  3. Estude APIs REST e integração entre sistemas.

  4. Aprenda conceitos de Large Language Models e Engenharia de Prompts.

  5. Explore arquiteturas de AI Agents.

  6. Conheça frameworks como LangGraph, CrewAI, AutoGen e OpenAI Agents SDK.

  7. Entenda protocolos de integração como MCP.

  8. Estude observabilidade, segurança e governança para sistemas de IA.

  9. Pratique a orquestração de múltiplos agentes em problemas reais.

  10. Desenvolva a habilidade mais importante de todas: pensar em sistemas, não apenas em programas.


Conclusão

A história da computação sempre caminhou em direção à especialização e à colaboração. Primeiro vieram os programas monolíticos, depois os sistemas distribuídos, os microsserviços e, agora, os Sistemas Multiagentes.

Para o Programador COBOL Padawan, essa não é uma ruptura com o passado, mas uma continuidade natural. Quem compreende como CICS, DB2, MQ, RACF, JES2 e z/OS colaboram para manter milhões de transações funcionando diariamente já possui uma base conceitual surpreendentemente próxima da lógica dos agentes de IA.

A próxima geração de software não será construída por uma única inteligência artificial onisciente. Ela será resultado da cooperação entre diversas inteligências especializadas, coordenadas por arquiteturas capazes de planejar, executar, validar e aprender continuamente.

E talvez a maior ironia dessa revolução seja esta: enquanto muitos acreditam que a IA está inventando uma forma completamente nova de computação, os profissionais de Mainframe podem reconhecer nela um velho conhecido. Há décadas, o IBM Z nos ensina que sistemas robustos nascem da colaboração entre componentes especializados, governados por uma arquitetura sólida e por princípios de engenharia bem estabelecidos.

Você não está apenas estudando Inteligência Artificial. Está ampliando sua visão sobre a evolução da engenharia de software e descobrindo que, no futuro, o profissional mais valioso não será aquele que compete com a IA, mas aquele que sabe construir, coordenar e orientar equipes inteiras de inteligências artificiais para resolver problemas que, sozinho, nenhum modelo conseguiria enfrentar.

segunda-feira, 20 de abril de 2026

💣 COBOL NÃO É LEGADO — É CARÁTER: O CAMINHO DO DEV QUE QUER SAIR DO “OPERADOR DE JOB” PARA ENGENHEIRO DE MISSÃO CRÍTICA

 

Bellacosa Mainframe uma conversa com DEVs Programadores COBOL

💣 COBOL NÃO É LEGADO — É CARÁTER: O CAMINHO DO DEV QUE QUER SAIR DO “OPERADOR DE JOB” PARA ENGENHEIRO DE MISSÃO CRÍTICA


Existe um mito silencioso no mundo corporativo:
o de que o desenvolvedor COBOL é apenas um “mantenedor de código antigo”.

Isso não só está errado — é perigoso.

Porque enquanto muitos enxergam “legado”, poucos entendem que estão sentados em cima de o sistema nervoso de bancos, seguradoras, bolsas e governos inteiros.

E aí vem a pergunta que separa os comuns dos raros:

👉 Você é um digitador de programa… ou um engenheiro de sistema crítico?


🧭 ORIGEM: QUANDO O COBOL NÃO ERA “VELHO” — ERA REVOLUCIONÁRIO

COBOL nasceu nos anos 60 com uma missão ousada:

ser compreensível para humanos de negócio

Enquanto outras linguagens eram matemáticas, o COBOL era quase… literatura.

Exemplo clássico:

ADD SALARIO TO TOTAL-PAGAMENTO.

Isso não é código. Isso é intenção.

💡 Easter Egg histórico:
A linguagem foi fortemente influenciada por Grace Hopper, que defendia que código deveria ser legível como inglês — algo que hoje o mundo redescobre com “clean code”.


⚠️ O PROBLEMA MODERNO: O DEV QUE PAROU NO TEMPO

O erro mais comum não é técnico.

É mental.

O dev COBOL muitas vezes cai em um desses perfis:

  • 🔁 “Eu só faço manutenção”
  • 🧱 “Sempre foi assim”
  • 📦 “Não mexe nisso que funciona”

Esse mindset transforma profissionais em… gargalos humanos.

E o mercado já percebeu isso.

Hoje não falta vaga para COBOL.
Falta gente que pensa além do COBOL.


🧠 EVOLUÇÃO REAL: O QUE SEPARA O DEV COMUM DO DIFERENCIADO

Vamos direto ao ponto.

1. 📊 ENTENDER O NEGÓCIO (DE VERDADE)

Se você não sabe o que seu programa faz no negócio…

👉 você é substituível.

Um dev COBOL de alto nível sabe responder:

  • Esse programa impacta qual produto bancário?
  • Qual risco financeiro existe aqui?
  • Qual o impacto de uma falha?

💡 Exemplo real:

Um simples IF mal feito pode gerar milhões em prejuízo em cálculo de juros.


2. 🔍 LER MAIS DO QUE ESCREVER

Dev COBOL sênior não escreve código rápido.

Ele entende código legado absurdo com facilidade.

Exemplo clássico:

IF WS-IND = 'S' OR 'Y' AND NOT = 'N'

👉 Isso aqui é bug esperando acontecer.

O profissional evoluído:

  • refatora
  • documenta
  • simplifica

3. ⚙️ DOMINAR O ECOSSISTEMA (NÃO SÓ COBOL)

COBOL sozinho não vive.

Você precisa dominar:

  • JCL (o sangue do batch)
  • CICS (o tempo real)
  • DB2 (a memória do sistema)
  • VSAM (o legado vivo)
  • SORT / IDCAMS (os bastidores)

💥 Easter Egg técnico:
Muitos problemas de “performance COBOL” são, na verdade, problemas de JCL mal desenhado ou acesso ineficiente ao DB2.


4. 🚀 PERFORMANCE É DIFERENCIAL (E POUCOS DOMINAM)

Um dev comum faz funcionar.
Um dev avançado faz escalar.

Exemplo:

  • Evitar READ NEXT desnecessário
  • Usar buffers corretamente
  • Reduzir I/O
  • Escolher entre VSAM vs DB2 com critério

💡 Curiosidade:
Mainframe ainda processa bilhões de transações por dia — e COBOL está no centro disso.


5. 🌐 APRENDER A CONVERSAR COM O MUNDO MODERNO

Aqui está o divisor de águas atual.

Você precisa saber integrar COBOL com:

  • APIs REST
  • JSON
  • Mensageria
  • z/OS Connect
  • Microservices

Exemplo simples de mentalidade:

Antes:

Programa batch gera arquivo

Depois:

Programa expõe serviço consumido por app mobile

💥 Isso muda tudo.


6. 🧩 REFACTORING: A ARTE QUE QUASE NINGUÉM FAZ

Código COBOL antigo muitas vezes é um labirinto.

Mas cuidado:

👉 refatorar sem entender é quebrar produção.

O profissional diferenciado:

  • entende fluxo completo
  • cria versões paralelas
  • valida com dados reais
  • documenta decisões

7. 📚 DOCUMENTAR COMO SE SUA VIDA DEPENDESSE DISSO

Porque depende.

Mainframe tem um problema clássico:

conhecimento tribal

Se você sair… o sistema para.

Quem documenta bem:

  • vira referência
  • cresce rápido
  • reduz riscos

🧪 EXEMPLO PRÁTICO: DO DEV COMUM AO ENGENHEIRO

Situação:

Programa COBOL lê VSAM e calcula saldo.

Dev comum:

  • ajusta campo
  • recompila
  • entrega

Dev evoluído:

  • entende regra de negócio
  • valida consistência histórica
  • analisa impacto em batch downstream
  • melhora performance
  • documenta fluxo
  • sugere evolução (API, por exemplo)

👉 Resultado: ele não entrega código.

Ele entrega segurança operacional.


🧿 FILOSOFIA DO MAINFRAME: DISCIPLINA > MODISMO

Enquanto o mundo corre atrás de frameworks…

o mainframe exige:

  • precisão
  • previsibilidade
  • responsabilidade

💡 Um erro aqui não derruba um site.

👉 Derruba um banco.


🧨 EASTER EGG FINAL (PARA QUEM É RAIZ)

Se você nunca:

  • analisou um dump S0C7 na unha
  • perseguiu um abend fantasma
  • ou depurou JOB em produção

… você ainda não viu o verdadeiro mainframe.


🏁 CONCLUSÃO: O DEV COBOL DO FUTURO NÃO É LEGADO — É RARO

O mercado não quer mais alguém que “sabe COBOL”.

Quer alguém que:

  • entende negócio
  • domina ecossistema
  • pensa em arquitetura
  • integra com o mundo moderno
  • resolve problemas críticos

👉 Isso não é um programador.

Isso é um engenheiro de missão crítica.


☕ FRASE FINAL (ESTILO BELLACOSA)

“COBOL não é sobre o passado.
É sobre quem tem coragem de carregar o presente… sem margem para erro.”

 

domingo, 19 de abril de 2026

💀 RONIN DO MAINFRAME: O CÓDIGO SEM SENHOR NO MUNDO CORPORATIVO

 

Bellacosa Mainframe fala sobre Ronins e Terceirização

💀 RONIN DO MAINFRAME: O CÓDIGO SEM SENHOR NO MUNDO CORPORATIVO

Existe um tipo de profissional que não pertence a lugar nenhum… mas é essencial em todos os lugares.
No Japão feudal, ele era chamado de ronin.
No mundo corporativo — especialmente no universo mainframe — ele atende por outro nome: o terceirizado de projeto.

E a semelhança vai muito além da estética.


⚔️ O QUE É UM RONIN, AFINAL?

A palavra ronin (浪人) significa literalmente “homem à deriva”.

No Japão feudal:

  • Era um samurai sem mestre (daimyō)
  • Perdia seu senhor por morte, desonra ou queda política
  • Ficava sem propósito fixo, sem renda e sem proteção

Mas não se engane…
Um ronin não era um fracasso.

Ele era, muitas vezes:

  • Extremamente habilidoso
  • Independente
  • Perigoso
  • E… livre demais para um sistema que exigia lealdade absoluta

💻 O RONIN DO MAINFRAME

Agora transporta isso para o nosso mundo…

O profissional que:

  • Entra em projetos críticos
  • Resolve o que ninguém resolve
  • Domina COBOL, JCL, CICS, DB2 como poucos
  • E… quando tudo estabiliza, é dispensado

Esse é o ronin corporativo.

Sem squad fixo.
Sem “casa”.
Sem pertencimento.

Mas com algo que poucos têm:
👉 capacidade de sobrevivência em qualquer ambiente hostil de TI


🔥 ANALOGIA DIRETA (SEM FILTRO)

Japão FeudalMainframe Corporativo
DaimyōCliente / Empresa
SamuraiFuncionário CLT
RoninTerceirizado
KatanaConhecimento técnico
Código de honra (Bushidō)Boas práticas, governança
SobrevivênciaAlocação em projetos

E aqui vem o ponto mais forte…

👉 O ronin não escolhe estabilidade.
👉 Ele escolhe movimento.


🧠 FILOSOFIA RONIN (QUE TODO DEV DEVERIA ENTENDER)

O ronin vive sob três regras não escritas:

1. 🧭 Você é sua própria reputação

Sem empresa para te “defender”, só existe:

  • Seu nome
  • Sua entrega
  • Seu histórico

No mainframe isso pesa ainda mais…
porque todo mundo se conhece.


2. ⚡ Aprender não é opcional

O ronin não tem zona de conforto.

Hoje é:

  • Batch noturno quebrando

Amanhã:

  • Problema em CICS com transação travando

Depois:

  • SQL de 1978 que ninguém entende

Se você não evolui… você desaparece.


3. 🏹 Desapego é sobrevivência

Terminou o projeto?

Você vai embora.

Sem despedida dramática.
Sem “vamos manter contato” que nunca acontece.

👉 Só o próximo desafio.


🏯 ORIGEM HISTÓRICA (CURIOSIDADE RAIZ)

Os ronin ficaram especialmente famosos após eventos como:

  • A era Tokugawa (1603–1868), quando guerras diminuíram
  • Muitos samurais ficaram sem função
  • Alguns viraram mercenários
  • Outros… professores, escritores ou até criminosos

O caso mais icônico:
👉 Os 47 Ronin

Um grupo que vingou seu mestre mesmo após anos — um dos maiores símbolos de lealdade da cultura japonesa.


🧩 EASTER EGGS QUE POUCA GENTE PERCEBE

  • 🔍 Muitos personagens de anime são “ronins modernos” (sem mestre, sem vínculo)
  • 💡 No mundo corporativo, o ronin é frequentemente o cara que “salva o legado”
  • ⚠️ Empresas dependem deles… mas raramente os valorizam corretamente
  • 🧠 O conhecimento deles é tácito, não documentado — um risco gigante

⚠️ O LADO SOMBRIO DO RONIN CORPORATIVO

Nem tudo é poesia.

Ser um ronin no mainframe também significa:

  • Falta de estabilidade
  • Pouco reconhecimento institucional
  • Desgaste constante
  • Necessidade de provar valor repetidamente

👉 É uma vida de guerra contínua.


🚀 O GRANDE PARADOXO

As empresas dizem querer:

  • Estabilidade
  • Padronização
  • Governança

Mas quando o sistema cai…

👉 Elas chamam o ronin.


☕ CONCLUSÃO ESTILO BELLACOSA

O ronin do mainframe não é só um profissional.

Ele é:

  • O cara que entra no caos
  • Entende código legado sem documentação
  • Resolve em silêncio
  • E desaparece antes dos aplausos

Enquanto muitos buscam conforto…

👉 O ronin busca relevância.

E no fundo, no fundo…

Todo ambiente crítico de mainframe sabe:

“Sem os ronins… muita coisa simplesmente pararia.”

 

sábado, 18 de abril de 2026

⚠️ O Erro Silencioso em VSAM: Como Escolher KSDS vs ESDS vs RRDS Pode Derrubar Seu Sistema (Sem Você Perceber)

 

Bellacosa Mainframe erros silenciosos no VSAM e cabum no sistema

⚠️ O Erro Silencioso em VSAM: Como Escolher KSDS vs ESDS vs RRDS Pode Derrubar Seu Sistema (Sem Você Perceber)

🔥 KSDS vs ESDS vs RRDS — A visão que só aparece em produção

🧠 Primeiro: o erro clássico

Muita gente aprende assim:

  • KSDS = com chave
  • ESDS = sequencial
  • RRDS = relativo

👉 Isso é tecnicamente correto…
👉 Mas arquiteturalmente incompleto

A decisão real é:

Como o sistema acessa, cresce e evolui ao longo do tempo?


🟦 1. KSDS (Key-Sequenced Data Set) — O “DB2 simplificado”

💡 O que ele realmente é

Um KSDS é basicamente um índice + dados organizados por chave.

👉 Pense como:

  • “mini banco de dados”
  • com acesso direto via índice

📌 Quando ele brilha (vida real)

✔ Sistemas OLTP (CICS principalmente)
✔ Lookup online em alta frequência
✔ Dados vivos (update/delete constantes)


🏦 Exemplo real (CICS bancário)

Arquivo: ACCT-MASTER (KSDS)
Chave: ACCOUNT-NUMBER

CICS READ FILE('ACCT') RIDFLD(WS-ACC)

👉 Aqui não existe “loop”
👉 É acesso direto → milissegundos


⚙️ Internamente (ponto que poucos exploram)

  • CI (Control Interval)
  • CA (Control Area)
  • Índice B-tree

Quando você faz INSERT fora de ordem:

👉 💥 CI SPLIT
👉 💥 CA SPLIT


🚨 Problema clássico de produção

Sistema crescendo + inserts aleatórios:

  • aumento de I/O
  • fragmentação
  • queda de performance

🔧 Solução clássica

//REORG EXEC PGM=IDCAMS
//SYSIN DD *
REPRO INFILE(IN) OUTFILE(OUT)
/*

👉 Rebalanceia tudo
👉 Melhora locality de acesso


🧠 Insight avançado

Se você vê:

  • KSDS com 90% inserts sequenciais
    👉 talvez ESDS fosse melhor

🟨 2. ESDS (Entry-Sequenced Data Set) — O “log natural”

💡 O que ele realmente é

Um ESDS é:

“append-only storage com endereço físico (RBA)”


📌 Quando ele brilha

✔ Batch pesado
✔ Logs
✔ Trilhas de auditoria
✔ Streaming de eventos


🧾 Exemplo real

Arquivo: TRANS-LOG (ESDS)

WRITE REGISTRO
WRITE REGISTRO
WRITE REGISTRO

👉 Sempre no final
👉 Sem reorganização de chave


🚀 Por que ele é rápido?

  • Sem index
  • Sem split
  • Escrita linear

👉 É praticamente I/O sequencial puro


⚠️ Limitação crítica

Você não faz:

READ WHERE ID = X

👉 Você precisa:

  • RBA (posição física)
    ou
  • ler sequencialmente

🔥 Caso real (erro clássico)

Projeto usando KSDS para log:

  • CI split constante
  • alto consumo de CPU

👉 Troca para ESDS:

  • batch caiu de 2h → 40 min

🧠 Insight avançado

ESDS é perfeito para:

👉 event sourcing no mainframe

(sim, isso existe e funciona muito bem)


🟥 3. RRDS (Relative Record Data Set) — O “array do mainframe”

💡 O que ele realmente é

Um RRDS é:

“um vetor indexado por posição (RRN)”


📌 Quando ele brilha

✔ Tabelas fixas
✔ Configuração
✔ Lookup ultra rápido sem chave


🧾 Exemplo real

RRN 1 → Config geral
RRN 2 → Limites
RRN 3 → Parâmetros regionais

Código:

READ FILE RRDS-FILE
RECORD NUMBER IS WS-RRN

👉 Acesso direto
👉 Sem índice
👉 Sem busca


⚡ Performance

  • O(1) direto
  • extremamente previsível

⚠️ Problemas

❌ Espaço desperdiçado
❌ Não escala bem
❌ Difícil de evoluir


🔥 Caso real

RRDS com 10.000 slots
Uso real: 300

👉 97% vazio
👉 storage desperdiçado


🧠 Insight avançado

RRDS é ótimo quando:

👉 você quer comportamento determinístico (tipo tabela estática em memória)


⚖️ Comparação prática (nível arquiteto)

CritérioKSDSESDSRRDS
Acesso por chave
Acesso sequencial
Acesso diretovia RBAvia RRN
Insertmédio🔥 rápidofixo
Update⚠️ difícillimitado
Espaçoeficienteeficiente❌ pode desperdiçar
Complexidademédiabaixabaixa

🧠 Decisão real (mentalidade de produção)

✔ Use KSDS quando:

👉 O negócio fala em ID, chave, busca direta


✔ Use ESDS quando:

👉 O sistema fala em log, trilha, histórico, append


✔ Use RRDS quando:

👉 O sistema fala em posição fixa, tabela estática


🔥 O insight que separa júnior de sênior

VSAM não é sobre “tipo de arquivo”
É sobre padrão de acesso + comportamento do dado


🚨 Anti-patterns clássicos

❌ KSDS para log
❌ ESDS para lookup
❌ RRDS para dados dinâmicos


💥 Extra (nível especialista)

🔄 Combinações reais em sistemas grandes

  • KSDS → dados ativos
  • ESDS → histórico/log
  • RRDS → parâmetros

👉 Isso é MUITO comum em sistemas CICS/Batch

sexta-feira, 17 de abril de 2026

💥 Operador de CICS Não Aperta Botão: Ele Evita Caos em Milhões de Transações (E Quase Ninguém Percebe)

 

Bellacosa Mainframe descreve as atividade de um operador mainframe em CICS

💥 Operador de CICS Não Aperta Botão: Ele Evita Caos em Milhões de Transações (E Quase Ninguém Percebe)

Se você acha que o operador de mainframe só “fica olhando tela verde”… cuidado.
No universo do CICS, ele é o guardião silencioso que impede filas travadas, regiões colapsando e clientes reclamando no app do banco.

Hoje vamos abrir essa caixa-preta no estilo Bellacosa Mainframe: direto, provocativo e com aquele tempero de quem já viu CICS pegando fogo às 3 da manhã. ☕


🧠 O Papel REAL do Operador de CICS

O operador não programa… mas mantém o sistema RESPIRANDO.

Ele atua em três frentes:

🔹 1. Monitoramento contínuo

  • Região CICS ativa?
  • Transações fluindo?
  • CPU explodindo?
  • Tasks presas?

🔹 2. Intervenção rápida

  • Mata transação travada
  • Habilita/desabilita recursos
  • Responde incidentes antes do usuário perceber

🔹 3. Comunicação

  • Aciona suporte (sysprog, dev, DBA)
  • Documenta incidentes
  • Traduz problema técnico em impacto real

👉 Em resumo:
O operador não resolve tudo — mas sabe exatamente quando algo está errado.


⚙️ Comandos CICS que TODO operador deve dominar

Dentro do CICS (via terminal ou console), esses são os clássicos:

🔥 CEMT — O CANIVETE SUÍÇO

O mais importante. Se o operador souber só um… que seja esse.

Exemplos:

CEMT I TASK

→ Lista tasks ativas

CEMT I TRANS

→ Mostra transações

CEMT SET TRANS(xxxx) DISABLED

→ Desabilita transação problemática

CEMT SET FILE(nome) CLOSED

→ Fecha arquivo (VSAM/DB2 ligado)

CEMT SET TASK(xxxx) PURGE

→ Mata task travada

💡 Dica Bellacosa:
Se você usou PURGE mais de 3x no dia… tem problema estrutural.


🔥 CEDA — Definições (nível mais avançado)

CEDA I TRANS(xxxx)

→ Ver definição da transação

👉 Operador usa menos, mas precisa reconhecer.


🔥 CECS / CECI — Testes

Mais usados por dev, mas operador esperto sabe identificar uso indevido.


🖥️ Onde o SDSF entra no jogo?

Aqui começa o poder real.

O SDSF é o radar do operador.


🔍 Telas que ele MAIS usa:

🔹 ST (Status)

  • Ver address space do CICS
  • CPU, memória, status

👉 Identificar se o CICS está:

  • Loopando
  • Travado
  • Consumindo CPU absurda

🔹 DA (Display Active)

  • Tasks no z/OS
  • Ver impacto fora do CICS

🔹 LOG

  • Mensagens do sistema

👉 Aqui mora o OURO.

Exemplo:

  • AICA abends
  • DFHxxxx mensagens
  • Falhas de recurso

💡 Easter egg:
Se aparecer DFHAC2001 com frequência…
👉 Pode apostar: alguém esqueceu commit ou está em loop.


🔹 SP (Spool)

  • Logs de jobs
  • Dumps

🚨 Quando o CICS está “aberto” — o que se espera do operador?

CICS aberto = ambiente em produção, usuários ativos.

O operador precisa:

✅ 1. Garantir disponibilidade

  • Região UP
  • Transações habilitadas

✅ 2. Detectar anomalias

  • Lentidão
  • Travamentos
  • Picos

✅ 3. Agir ANTES do caos

  • Kill de tasks
  • Disable de transação problemática

✅ 4. Seguir procedimento

  • Nada de “inventar moda”
  • Produção NÃO é laboratório

🧨 Situações clássicas (vida real)

💣 Caso 1 — Loop infinito

Sintoma:

  • CPU 100%
  • Usuários travados

Ação:

CEMT I TASK
CEMT SET TASK(xxxx) PURGE

💣 Caso 2 — Arquivo travado

Sintoma:

  • Transações não respondem

Ação:

CEMT SET FILE(nome) CLOSED
CEMT SET FILE(nome) OPEN

💣 Caso 3 — Transação problemática

CEMT SET TRANS(xxxx) DISABLED

🕵️ Curiosidade raiz (história real de datacenter)

Um operador notou que o CICS estava “normal”…
Mas usuários reclamavam.

Ele fez algo simples:

CEMT I TASK

Percebeu centenas de tasks iguais.

👉 Era um bug em produção gerando loop silencioso.

Ele matou UMA task… e o problema sumiu.

💡 Moral:
Nem sempre o problema é barulhento.


🎯 Dicas nível Bellacosa (ouro puro)

🔥 Nunca saia dando PURGE sem entender
🔥 Sempre olhe o SDSF antes de agir
🔥 Aprenda a reconhecer padrões (isso separa operador de operador)
🔥 Documente TUDO
🔥 Conheça mensagens DFH (isso é superpoder)


🧩 Easter Egg técnico

Se você digitar:

CEMT I SYSTEM

Vai ver:

  • Status geral
  • Recursos
  • Saúde do CICS

👉 Pouca gente usa… mas deveria.


🚀 Conclusão

O operador de CICS não é figurante.
Ele é o primeiro firewall humano entre o sistema e o caos.

Enquanto desenvolvedores escrevem código…
👉 Ele garante que o sistema NÃO PARE.

E quando tudo está funcionando perfeitamente…










👉 Foi porque ele fez o trabalho certo — e ninguém percebeu.


quinta-feira, 16 de abril de 2026

💥 CICS Não é Legado: Como o CICS TS 6.3 Está Processando Milhões de Transações por Segundo (Enquanto o Mundo Ainda Subestima o Mainframe)

 

Bellacosa Mainframe apresenta o CICS TS versão 6.3

💥 CICS Não é Legado: Como o CICS TS 6.3 Está Processando Milhões de Transações por Segundo (Enquanto o Mundo Ainda Subestima o Mainframe)

🧠 CICS Transaction Server – visão geral atual

O produto que manda no jogo é o
👉 IBM CICS Transaction Server for z/OS

  • Middleware transacional de altíssimo volume
  • Base de praticamente todos os bancos, seguradoras e governos
  • Arquitetura cooperativa de multitarefa (quase um “mini-OS dentro do z/OS”)

🚀 Versão mais recente (estado da arte)

👉 Versão atual: CICS TS 6.3
👉 Data de GA: 05 de setembro de 2025

📌 Importante:

  • A linha 6.x segue modelo continuous delivery
  • Atualizações continuam saindo (inclusive em 2026)

🧬 Evolução recente (6.1 → 6.2 → 6.3)

🟢 CICS TS 6.1 (2022)

  • Base da nova geração
  • Foco:
    • APIs modernas
    • Cloud enablement
    • Melhor governança operacional

🟡 CICS TS 6.2 (2024)

  • Performance tuning pesado
  • Melhorias operacionais reais (não só dev)
  • Consolidação da documentação (6.x unificado)

💡 Destaque Bellacosa:

Aqui o CICS começou a “respirar DevOps de verdade”


🔵 CICS TS 6.3 (2025 – atual)

  • Foco forte em:
    • Observabilidade (OpenTelemetry)
    • Segurança
    • Automação operacional
    • Integração com APIs modernas

Exemplo prático:

  • Flush automático de dados de telemetria (SMF + observabilidade moderna)

🔐 Segurança evoluída

  • HSTS (HTTP Strict Transport Security)
  • Melhor visibilidade de login (tentativas, timestamps)

⚙️ Limites operacionais (o que ninguém te explica direito)

Agora vem o ouro 👇 (estilo Bellacosa raiz)

👥 Limite de usuários

👉 Não existe limite fixo definido pelo CICS

Depende de:

  • Região (QR TCB)
  • Storage (EDSAs / GDSA / RDSA)
  • Tuning de SIT

💡 Na prática:

  • Milhares de usuários simultâneos são comuns
  • Bancos operam com dezenas de milhares

🧵 Limite de tasks (TCLASS / MAXTASKS)

👉 Controlado por:

  • MXT (Max Tasks global da região)
  • TCLASS (limite por tipo de workload)

💥 Valores típicos:

  • MXT: 500 até 2000+ (ou mais em ambientes modernos)
  • Pode escalar dependendo de CPU e tuning

📌 Importante:

  • Cada transação = 1 TASK
  • CICS é cooperativo (não preemptivo)

🔁 Limite de transações por segundo (TPS)

👉 Não existe limite fixo no produto

Depende de:

  • CPU (MSU / MIPS)
  • I/O (VSAM / DB2 / MQ)
  • Locking
  • Design da aplicação

💥 Casos reais:

  • 10.000+ TPS → comum
  • 50.000+ TPS → ambientes financeiros pesados

🧠 Limite de memória (Storage)

Controlado por:

  • DSAs:
    • CDSA
    • EDSA
    • RDSA
  • 31-bit vs 64-bit storage

💡 Tendência moderna:
👉 mover tudo possível para 64-bit storage (above the bar)


🧬 Limite de regiões CICS

👉 Ilimitado na prática (depende do z/OS)

Arquiteturas modernas usam:

  • CICSPlex SM
  • TOR / AOR / FOR separation

🏗️ Arquitetura operacional (visão de campo)

🧩 Componentes chave

  • QR TCB → coração da região
  • Open TCBs → paralelismo real (DB2, MQ, Java)
  • Dispatcher CICS → controla multitarefa
  • Program Control (PC)
  • Task Control (TC)

🔄 Modelo de execução

  1. Terminal / API chama transação
  2. CICS cria TASK
  3. Dispatcher gerencia CPU
  4. TASK usa serviços:
    • VSAM
    • DB2
    • MQ
  5. Commit (syncpoint)

🔥 O que realmente mudou (visão prática)

Antes (CICS clássico)

  • 3270
  • COBOL puro
  • VSAM pesado
  • Transação síncrona

Agora (CICS moderno)

  • REST via z/OS Connect
  • APIs JSON
  • Observabilidade (OpenTelemetry)
  • Integração cloud
  • DevOps pipeline

💥 Em resumo:
👉 CICS virou Application Server corporativo de missão crítica


📊 Pontos fortes atuais

  • Escalabilidade absurda (vertical + horizontal)
  • Resiliência (quase zero downtime)
  • Integração híbrida (legacy + cloud)
  • Segurança nível bancário

⚠️ Gargalos reais (sem romantizar)

  • Aplicação mal escrita = gargalo (não o CICS)
  • Lock em VSAM/DB2
  • TASK segurando CPU (não liberando)
  • Storage mal dimensionado
  • Falta de paralelismo (Open TCB subutilizado)

🧠 Conclusão estilo Bellacosa

CICS hoje não é legado.

👉 É core digital escondido atrás de APIs modernas

E a versão 6.3 consolida isso:

  • Mais observável
  • Mais seguro
  • Mais integrado
  • Mais preparado para cloud