Translate

Mostrar mensagens com a etiqueta desenvolvimento mainframe. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta desenvolvimento mainframe. Mostrar todas as mensagens

segunda-feira, 1 de junho de 2026

☕💣 DÍVIDA TÉCNICA: O MONSTRO INVISÍVEL QUE ESTÁ COMENDO O SEU COBOL DESDE O SÉCULO PASSADO

 

Bellacosa Mainframe e o monstro da divida tecnica 

☕💣 DÍVIDA TÉCNICA: O MONSTRO INVISÍVEL QUE ESTÁ COMENDO O SEU COBOL DESDE O SÉCULO PASSADO

"O sistema funciona perfeitamente. Só ninguém sabe como."

Se você trabalha com Mainframe há algum tempo, provavelmente já ouviu frases como:

  • "Não mexe nisso que funciona."

  • "Esse programa está em produção há 20 anos."

  • "Só o João sabe alterar esse módulo."

  • "Depois a gente documenta."

  • "Precisamos entregar hoje."

Parabéns.

Você acabou de encontrar alguns dos maiores sintomas de uma das doenças mais comuns da tecnologia moderna:

A Dívida Técnica.

E não, ela não acontece apenas em Java, Python ou aplicações web modernas.

Na verdade, muitos dos maiores casos de dívida técnica do planeta estão rodando neste exato momento em sistemas COBOL responsáveis por bancos, seguradoras, governos, companhias aéreas e bolsas de valores.

Vamos entender o que é, como identificar, controlar e principalmente como sobreviver a ela.


O QUE É DÍVIDA TÉCNICA?

A definição mais simples é:

Dívida Técnica é o custo futuro gerado quando escolhemos uma solução rápida hoje em vez da melhor solução possível.

Imagine que você recebeu uma demanda urgente.

O gerente aparece correndo:

"Precisamos colocar essa alteração em produção amanhã."

Você sabe que o correto seria:

  • revisar a arquitetura;

  • atualizar documentação;

  • criar casos de teste;

  • revisar impactos;

  • atualizar fluxogramas.

Mas o prazo não permite.

Então você faz um ajuste rápido.

Entrega.

Todo mundo feliz.

Até que seis meses depois alguém precisa alterar novamente aquele trecho.

Agora ninguém entende mais nada.

A dívida venceu.

E os juros começaram a ser cobrados.


A ANALOGIA COM O CARTÃO DE CRÉDITO

A comparação mais famosa é com uma dívida financeira.

Quando você compra algo parcelado:

Você ganha agora.

Mas paga depois.

Na dívida técnica acontece exatamente o mesmo.

Você ganha:

  • velocidade;

  • prazo;

  • entrega rápida.

Mas paga depois com:

  • bugs;

  • retrabalho;

  • manutenção cara;

  • incidentes de produção.

Quanto mais tempo passa, maiores ficam os juros.


O COBOL NÃO CRIA DÍVIDA TÉCNICA

Essa é uma das maiores injustiças da informática.

Muitos dizem:

"Cobol é dívida técnica."

Errado.

COBOL não é dívida técnica.

COBOL mal mantido é dívida técnica.

Existem programas COBOL escritos há 30 anos que continuam:

  • legíveis;

  • documentados;

  • organizados;

  • eficientes.

E existem aplicações modernas escritas há seis meses que já parecem um filme de terror.

A linguagem não é o problema.

A disciplina é.


COMO A DÍVIDA TÉCNICA NASCE

Ela normalmente surge de quatro formas.

1. Pressão por prazo

O caso mais comum.

"Entrega primeiro."

"Arruma depois."

O problema é que o depois quase nunca chega.


2. Falta de documentação

O desenvolvedor conhece tudo.

Então ele pensa:

"Não preciso documentar."

Dois anos depois ele muda de empresa.

Agora ninguém entende o programa.


3. Correções emergenciais

Produção caiu.

Cliente está ligando.

Diretoria está nervosa.

O objetivo vira apenas:

"Faça voltar."

Nesse momento quase ninguém pensa em qualidade.


4. Sistemas legados

Bibliotecas antigas.

COPYBOOKs herdados.

Macros esquecidas.

JCLs copiados durante décadas.

Tudo isso acumula dívida.


EXEMPLO REAL DE DÍVIDA TÉCNICA EM COBOL

Imagine um cálculo de desconto.

Versão original:

IF CLIENTE-VIP
   COMPUTE DESCONTO = VALOR * 0.15
END-IF

Simples.

Legível.

Agora passam dez anos.

Novas regras surgem.

Resultado:

IF CLIENTE-TIPO = 'A'
...
ELSE
IF CLIENTE-TIPO = 'B'
...
ELSE
IF CLIENTE-TIPO = 'C'
...

Mais tarde:

IF CLIENTE-TIPO = 'A'
...
ELSE
IF CLIENTE-TIPO = 'B'
...
ELSE
IF CLIENTE-TIPO = 'C'
...
ELSE
IF REGIAO = 'S'
...

Depois de centenas de mudanças:

Ninguém sabe mais como o cálculo funciona.

O programa funciona.

Mas ninguém entende.

Isso é dívida técnica.


OS SINTOMAS MAIS PERIGOSOS

Se você encontrar estes sinais, ligue o alerta.

Programas gigantes

Mais de 10.000 linhas.

COPYBOOKs duplicados

A mesma estrutura em vários lugares.

JCLs clonados

Mudam apenas o nome do JOB.

Falta de comentários

Tudo depende da memória dos analistas.

Testes manuais

Ninguém consegue validar rapidamente.

Dependência de uma pessoa

"O Carlos sabe."

Quando você ouve isso, existe dívida técnica.


O EFEITO JUROS COMPOSTOS

Aqui está a parte assustadora.

Dívida técnica cresce de forma parecida com juros compostos.

Um bug gera:

  • remendo;

  • novo remendo;

  • ajuste do remendo;

  • correção da correção.

Depois de alguns anos ninguém consegue alterar sem medo.

O custo explode.


COMO MAPEAR DÍVIDA TÉCNICA

Primeiro passo:

Pare de adivinhar.

Crie um inventário.

Faça uma planilha simples.

Colunas:

  • Sistema

  • Programa

  • Problema

  • Impacto

  • Complexidade

  • Prioridade

Exemplo:

ProgramaProblemaImpacto
COBCLI01Sem documentaçãoAlto
COBFAT0212.000 linhasAlto
COBPAG03Sem testesMédio

Agora a dívida virou algo visível.


MÉTRICAS IMPORTANTES

Um programador júnior deve aprender a medir.

Algumas métricas úteis:

Número de ABENDs

Se cresce continuamente:

há algo errado.


Tempo de correção

Quanto tempo leva para corrigir um incidente?

Quanto maior, maior a dívida.


Quantidade de módulos sem documentação

Métrica simples e poderosa.


Cobertura de testes

Quanto mais baixa, maior o risco.


FERRAMENTAS ÚTEIS NO MAINFRAME

Muitos iniciantes acham que Mainframe não possui ferramentas modernas.

Possui.

E muitas.

IBM Application Discovery

Mapeia dependências.

Excelente para sistemas gigantes.


IBM ADDI

Application Discovery and Delivery Intelligence.

Mostra relacionamentos entre:

  • COBOL

  • JCL

  • DB2

  • CICS


IBM Debug Tool

Ajuda a entender comportamento de programas complexos.


IBM Fault Analyzer

Investiga ABENDs.


IBM File Manager

Analisa arquivos rapidamente.


IBM Dependency Based Build

Automação moderna para pipelines Mainframe.


COMO REDUZIR A DÍVIDA

Agora vem a parte prática.


Passo 1 – Pare de criar dívida nova

Antes de pagar a antiga.

Evite criar mais.

Parece óbvio.

Mas é onde tudo começa.


Passo 2 – Refatore pequenos trechos

Não tente reescrever tudo.

Ataque pequenas áreas.

Exemplo:

  • nomes ruins;

  • IFs excessivos;

  • parágrafos gigantes.


Passo 3 – Documente enquanto aprende

Cada descoberta vira documentação.

Não espere um projeto oficial.


Passo 4 – Automatize testes

Mesmo testes simples ajudam.

Menos medo de alterar.

Mais velocidade.


Passo 5 – Padronize

Defina padrões.

Por exemplo:

  • nomenclatura;

  • comentários;

  • estrutura de programas;

  • organização de COPYBOOKs.


O ERRO MAIS COMUM DOS JUNIORES

Achar que refatorar significa reescrever tudo.

Não.

Refatoração significa melhorar sem alterar comportamento.

Você limpa.

Organiza.

Simplifica.

Sem mudar resultado.


O SEGREDO DOS ANALISTAS SENIORES

Muitos iniciantes acreditam que profissionais experientes sabem tudo.

Não sabem.

A diferença é que eles:

  • documentam mais;

  • investigam melhor;

  • evitam atalhos perigosos;

  • controlam a dívida técnica.

O conhecimento não está apenas no código.

Está na disciplina.


EASTER EGG DOS MAINFRAMEIROS

Se encontrar um comentário parecido com:

* NÃO REMOVER
* FUNCIONA ASSIM DESDE 1994

Você provavelmente encontrou um artefato arqueológico corporativo.

Trate com respeito.

Mas investigue.

Porque muitas vezes ele esconde uma dívida técnica histórica.


A REGRA DOS 5 MINUTOS

Uma dica poderosa.

Se você gastou cinco minutos para entender algo complicado:

documente.

O próximo desenvolvedor agradecerá.

E talvez esse próximo desenvolvedor seja você daqui a seis meses.


COMO EVOLUIR NA CARREIRA ATRAVÉS DA DÍVIDA TÉCNICA

Os melhores profissionais não são os que criam mais código.

São os que reduzem complexidade.

Quando você aprende a:

  • mapear problemas;

  • documentar;

  • simplificar;

  • automatizar;

  • refatorar;

você deixa de ser apenas um programador.

Você passa a ser um engenheiro de software.


CONCLUSÃO

Dívida técnica não é um bug.

Não é um ABEND.

Não é um programa COBOL antigo.

Ela é o resultado de decisões acumuladas ao longo do tempo.

Algumas são necessárias.

Outras são perigosas.

O segredo não é eliminar toda dívida técnica.

Isso é impossível.

O segredo é conhecê-la, monitorá-la e pagá-la antes que ela assuma o controle do sistema.

Porque, no final das contas, o verdadeiro problema não é aquele programa COBOL de 1987.

O problema é ninguém mais entender por que ele ainda funciona.

E quando esse dia chega...

o próximo chamado de produção costuma acontecer às 03:17 da manhã de um domingo.

Aproveite e conheça BACKLOG

https://eljefemidnightlunch.blogspot.com/2025/01/backlog-o-arquivo-secreto-que-separa-um.html

Backlog


terça-feira, 26 de maio de 2026

☕🟩 “DA TELA VERDE AO VS CODE: A GUERRA DAS IDEs MAINFRAME QUE NINGUÉM TE CONTOU”

 

Bellacosa Mainframe e as muitas ides de desenvolvimento do COBOL


☕🟩 “DA TELA VERDE AO VS CODE: A GUERRA DAS IDEs MAINFRAME QUE NINGUÉM TE CONTOU”

"Enquanto o programador moderno instala 847 extensões no VS Code… o veterano do ISPF compila COBOL usando apenas PF3, ódio corporativo e café."


Existe uma jornada secreta no mundo mainframe.

Todo programador z/OS passa por ela.

É quase uma evolução Pokémon corporativa:

ISPF → RDz → IDz → Zowe → VS Code → “volta pro ISPF porque era mais rápido”

E cada geração acredita que encontrou “a IDE definitiva”.

Spoiler:
ninguém encontrou.

Porque no fundo…
o programador mainframe ama sofrer um pouquinho.


🟩 ISPF — O IMPERADOR DA TELA VERDE


Sucessor das folhas de codificação

Antes de Eclipse.

Antes do Java.

Antes do VS Code existir.

Antes de metade da internet nascer.

Já existia o ISPF.

O Interactive System Productivity Facility.

Ou como muitos chamam:

“O cockpit do operador Jedi do mainframe.”

Criado nos anos 70, o ISPF não era bonito.
Ele era EFICIENTE.

Sem mouse.
Sem animação.
Sem autocomplete coloridinho gamer.

Mas absurdamente rápido.

Veteranos digitam comandos ISPF numa velocidade que parece hack.

Você pisca…
e o cara já:

  • abriu dataset,

  • editou membro,

  • compilou COBOL,

  • submeteu JCL,

  • analisou spool,

  • corrigiu abend,

  • e ainda reclamou do Java.

Tudo em 40 segundos.


🚀 O Segredo da Performance do ISPF

Aqui vem um easter egg que juniors não acreditam:

O ISPF consome RIDICULAMENTE pouca memória.

Enquanto IDEs modernas:

  • comem gigabytes de RAM,

  • abrem 19 processos,

  • travam por causa de plugin,

o ISPF praticamente roda no poder da determinação humana.

Em muitos ambientes:

  • 2 MB já eram luxo,

  • 8 MB parecia ficção científica,

  • e ainda assim o sistema inteiro voava.

O motivo?

Tudo era pensado para:

  • eficiência,

  • terminal remoto,

  • baixo consumo,

  • alta responsividade.

O ISPF é tão rápido porque ele nasceu num mundo onde desperdiçar CPU era pecado mortal.


☕ Eclipse — O Portal Que Trouxe o Mainframe ao Mundo Moderno

Aí chegou o Eclipse.

E o mundo mainframe olhou desconfiado.

Porque pela primeira vez alguém disse:

“E se o programador COBOL usar mouse?”

Silêncio absoluto no datacenter.


🟦 RDz — Rational Developer for z Systems

O lendário RDz surgiu como a grande modernização visual do desenvolvimento z/OS.

Depois virou:

  • Rational Developer for System z

  • Rational Developer for z Systems

  • e mais tarde IDz.

O RDz trouxe:

  • syntax highlight,

  • autocomplete,

  • debug visual,

  • integração DB2,

  • remote edit,

  • projetos modernos,

  • interface gráfica.

Os juniors acharam mágico.

Os veteranos disseram:

“isso é lento.”

E honestamente?
Eles tinham razão em parte.


🧠 O Eclipse Tinha FOME

O Eclipse revolucionou o desenvolvimento mainframe…

mas também inaugurou um novo conceito:

“Quanto mais plugin, mais sofrimento.”

RDz/IDz dependiam muito da JVM.

Então começaram os fenômenos paranormais:

  • OutOfMemoryError,

  • workspace corrompido,

  • garbage collection assassina,

  • travamentos misteriosos,

  • startup de 4 minutos.

Programadores começaram a decorar parâmetros JVM como magias ocultas:

-Xms512m
-Xmx4096m

Na época isso parecia MUITA memória.

Hoje o Chrome usa isso só pra abrir duas abas do YouTube.


🟨 IDz — IBM Developer for z/OS

IBM Developer for z/OS

O RDz evoluiu para o atual IBM Developer for z/OS (IDz). (IBM)

A versão moderna continua baseada em Eclipse, mas muito mais refinada.

Recursos atuais:

  • integração Git,

  • pipelines DevOps,

  • debugging avançado,

  • análise de impacto,

  • integração com APIs,

  • suporte híbrido,

  • AI assistance.

A IBM hoje posiciona o IDz como parte da modernização enterprise do z/OS. (IBM)


📅 Release Atual

As linhas atuais giram em torno da família 16.x do IDz/IDzEE. (IBM)


🧠 Memória e Performance

Aqui entra uma verdade universal:

Quanto maior o workspace COBOL…
mais RAM você oferece em sacrifício.

Projetos enormes:

  • copybooks gigantes,

  • milhões de linhas,

  • análise cross-reference,

fazem o Eclipse sofrer.

Ambientes corporativos frequentemente usam:

  • 4 GB até 8 GB JVM,

  • SSD obrigatório,

  • muito tuning.

Mesmo assim…

o autocomplete COBOL moderno impressiona MUITO.


⚡ KDz — O Eclipse “Turbo Corporativo”

Pouca gente lembra do apelido KDz.

Muitos ambientes chamavam certas distribuições customizadas do Developer for z como:

  • KDz,

  • KDz tooling,

  • kits corporativos z/OS.

Em geral eram empacotamentos enterprise:

  • plugins internos,

  • integração RACF,

  • ferramentas DevOps,

  • scanners,

  • analyzers.

O problema?

Cada empresa criava um “Frankenstein Eclipse”.

Resultado:

  • 14 plugins incompatíveis,

  • 9 versões Java,

  • workspace amaldiçoado,

  • startup digno de filme de terror.


🟦 Visual Studio Code — O Escolhido da Nova Geração

Então surgiu o VS Code.

Leve.
Rápido.
Moderno.

E o mundo mainframe falou:

“Finalmente.”


🔥 Wazi Developer for VS Code

A IBM percebeu algo importante:

Os juniors NÃO queriam Eclipse pesado.

Então nasceu o:
IBM Developer for z/OS on VS Code, antigo Wazi for VS Code. (IBM)

Ele usa:

  • VS Code,

  • Z Open Editor,

  • integração Zowe,

  • debug moderno,

  • Git nativo,

  • APIs.

Hoje é uma das maiores apostas da IBM para atrair nova geração.


📅 Releases Atuais


🚀 Performance

Aqui acontece a magia.

VS Code:

  • inicia rápido,

  • consome menos RAM,

  • responde melhor,

  • tem ecossistema moderno.

Muitos ambientes rodam confortavelmente com:

  • 1 GB a 2 GB RAM,

  • contra múltiplos GB do Eclipse.

E isso seduziu MUITO programador COBOL novo.


🟪 Zowe — O “Linux do Mainframe”

Zowe Project


O Zowe foi outro terremoto cultural.

Porque ele trouxe algo impensável:

mainframe via CLI moderna

Veteranos ficaram confusos vendo:

  • npm,

  • Node.js,

  • REST API,

  • terminal moderno falando com z/OS.

Parecia cyberpunk corporativo.


🧠 O Que o Zowe Mudou

O Zowe criou:

  • APIs REST para z/OS,

  • CLI moderna,

  • integração DevOps,

  • extensões VS Code,

  • acesso datasets via interface moderna.

Hoje ele é praticamente peça-chave da modernização mainframe. (Zowe Docs)


📅 Release Atual

A linha moderna está na família:

  • Zowe V3.x em evolução contínua durante 2025–2026. (Zowe Docs)


☕ O Plot Twist Final

E depois de tudo isso…

sabe o que muitos veteranos fazem?

Voltam pro ISPF.

Porque:

  • PF8 ainda é mais rápido,

  • split screen é lendário,

  • editar dataset gigante no 3270 continua absurdo,

  • e submitar JCL no painel 3.4 é praticamente arte marcial.


🛸 O Futuro das IDEs Mainframe

Hoje o ecossistema está dividido:

FerramentaFilosofia
ISPFvelocidade bruta
Eclipse / IDzenterprise pesado
VS Codemodernização leve
ZoweDevOps/API/cloud
Waziponte nova geração
3270religião corporativa

E o mais curioso?

TODAS coexistem.

Porque o mainframe não abandona tecnologia.
Ele acumula.

Como um dragão corporativo guardando tesouros tecnológicos de 50 anos.


☕ Conclusão Bellacosa Mainframe

O mundo moderno acha que evolução tecnológica significa substituir tudo.

O mainframe pensa diferente.

Ele acredita em:

  • compatibilidade,

  • estabilidade,

  • coexistência,

  • sobrevivência.

Por isso hoje você encontra:

  • ISPF dos anos 70,

  • Eclipse dos anos 2000,

  • VS Code moderno,

  • APIs REST,

  • IA,

  • OpenShift,

  • Kubernetes,

  • e COBOL…

todos funcionando juntos no MESMO ambiente.

E honestamente?

Isso é uma das coisas mais incríveis da computação moderna.


☕🟩 Bellacosa Mainframe
"Enquanto o VS Code baixa extensões… o ISPF já compilou o COBOL e foi tomar café."

Se eu esqueci de alguma IDE, deixe nos comentarios para enriquecer ainda mais esse artigo.


segunda-feira, 8 de dezembro de 2025

💥 SEU COBOL NÃO É LEGADO — É UM MOTOR TRANSACIONAL DE GUERRA: O Guia Definitivo de CICS TS no IBM z17 para Quem Quer Dominar Produção

 

Bellacosa Mainframe domine o CICS TS

💥 SEU COBOL NÃO É LEGADO — É UM MOTOR TRANSACIONAL DE GUERRA: O Guia Definitivo de CICS TS no IBM z17 para Quem Quer Dominar Produção

Se você ainda trata CICS como “aquele negócio antigo que roda COBOL”, está deixando dinheiro — e poder — na mesa.

O CICS TS (Customer Information Control System – Transaction Server) não é passado.
Ele é o motor invisível que sustenta bancos, seguros, governos e bilhões de transações por dia — agora turbinado no IBM z17.

E aqui vai o ponto que poucos entendem:

👉 CICS não executa programas. Ele orquestra negócios em tempo real com consistência absoluta.

Este artigo é um mergulho direto — técnico, prático e provocativo — para quem já vive de COBOL e quer ir além do “funciona”.


🏛️ Origem: Quando tudo começou (e por que ainda domina)

O CICS nasceu nos anos 60/70 dentro da IBM para resolver um problema brutal:

💥 Processar milhares de transações simultâneas com integridade garantida

Na época:

  • Bancos migravam de batch para online
  • Terminais 3270 surgiam
  • Usuários queriam resposta imediata

O resultado?

🔥 Nasceu o monitor transacional mais robusto da história

E ele evoluiu:

  • MVS → z/OS
  • SNA → TCP/IP
  • 3270 → APIs REST
  • COBOL → integração com Java, Node, APIs

Hoje, no IBM z17, o CICS é:

👉 Cloud-ready
👉 API-driven
👉 Integrado com IA e automação


⚙️ O que é CICS TS de verdade (sem romantismo)

CICS é:

👉 Um Transaction Processing Monitor (TP Monitor)
👉 Um gerenciador de recursos
👉 Um coordenador de consistência

Mas principalmente:

💥 Um orquestrador de Units of Work


🧠 Conceitos que você NÃO pode confundir

🔹 Transaction vs Task vs Unit of Work

ConceitoO que é
TransactionPedido do usuário
TaskExecução da transaction
Unit of WorkConjunto atômico de operações

👉 Regra de ouro:

Falhou antes do commit? Tudo volta. SEMPRE.


💣 Deadlock (o clássico)

Dois programas esperando recursos um do outro:

💥 Travou tudo.

O CICS resolve:

  • Detecta
  • Aborta uma task
  • Faz backout
  • Libera recursos

👉 Isso acontece silenciosamente — e salva sistemas inteiros.


🏗️ Arquitetura CICS (visão de quem trabalha em produção)

🧩 Componentes principais

  • Region → Address space no z/OS
  • Programs → COBOL, PL/I etc.
  • Resources → arquivos, filas, conexões
  • CSD → definições
  • Catalogs → estado do sistema

🚀 Como uma região nasce

Você não “abre” um CICS.

Você invoca:

// Started Task
S CICSTS

ou

// Batch
EXEC PGM=DFHSIP

👉 Isso sobe uma região completa, não só um programa.


🌐 Comunicação: onde o CICS virou moderno

🔹 MRO (Multiregion Operation)

👉 Comunicação interna (mesmo sysplex)

🔹 ISC (Intersystem Communication)

👉 Comunicação entre hosts

🔹 CTG (CICS Transaction Gateway)

👉 Porta de entrada para o mundo moderno

  • Java
  • APIs
  • Web apps

👉 Aqui o COBOL vira backend de API.


💾 Data Sets — onde muita gente cai (inclusive prova 😏)

Se você quer subir de nível, entenda isso:


📘 CSD (CICS System Definition)

👉 “O que pode existir”

  • Programs
  • Transactions
  • Files

💾 Global Catalog

👉 “Estado persistente”

  • Informações entre execuções
  • Localização do system log
  • Dados internos de domínio

📊 SMF (System Management Facility)

👉 Performance, auditoria e estatísticas


💥 Dumps

  • System dump → região inteira
  • Transaction dump → uma task

🧵 Log do CICS

👉 Primary + Secondary = Log lógico

Sem isso?

💀 Recovery comprometido


📬 TDQ vs TSQ

  • TDQ Intrapartition → dentro do CICS
  • TDQ Extrapartition → fora
  • TSQ → armazenamento temporário

👉 Pergunta clássica de prova.


🧪 Easter Eggs de quem vive CICS

💡 CEMT não morreu — só não é mais suficiente
→ CICS Explorer domina ambientes modernos

💡 Transaction ≠ Task (erro clássico de iniciante)

💡 Você raramente vê o CICS falhar — ele se recupera antes

💡 Deadlocks acontecem mais do que você imagina

💡 SMF é onde está a verdade — não o log da aplicação

💡 Grande parte do “problema COBOL” é, na verdade, problema de arquitetura CICS


🧭 Passo a passo mental de uma transação

Usuário → Transaction → Task → Program → Recursos → Syncpoint → Commit/Backout

Se tudo der certo:

✅ Commit

Se algo falhar:

💥 Backout total


🏆 O segredo que separa júnior de sênior

Um dev comum pensa:

👉 “Meu programa funcionou?”

Um dev COBOL sênior pensa:

👉 “Minha Unit of Work é segura?”
👉 “E se der rollback?”
👉 “E concorrência?”
👉 “E recovery?”
👉 “E performance no SMF?”


🚀 CICS no IBM z17: o presente (não o passado)

Hoje o CICS está:

  • Integrado com APIs REST
  • Consumido por microservices
  • Conectado via MQ
  • Automatizado com RPA
  • Monitorado em tempo real

👉 O COBOL virou motor de backend crítico.


🔥 Conclusão (provocação final)

Se você ainda chama CICS de legado…

👉 Você não entendeu o jogo.

CICS é:

💥 Consistência em escala
💥 Processamento em tempo real
💥 Engenharia de missão crítica

E no IBM z17, ele não está sobrevivendo.

👉 Ele está dominando silenciosamente o mundo corporativo.


sexta-feira, 13 de junho de 2025

☕💣 FUNÇÕES SEM SUBPROGRAMAS? O DIA EM QUE O COBOL APRENDEU A CRIAR SUAS PRÓPRIAS APIs — E QUASE NINGUÉM PERCEBEU

 

Bellacosa Mainframe apresenta as funçoes criadas em cobol modo api on

☕💣 FUNÇÕES SEM SUBPROGRAMAS? O DIA EM QUE O COBOL APRENDEU A CRIAR SUAS PRÓPRIAS APIs — E QUASE NINGUÉM PERCEBEU

Existe um momento na carreira de todo profissional de Mainframe em que ele descobre algo e pensa:

"Como ninguém me contou isso antes?"

Foi exatamente essa sensação que muitos desenvolvedores tiveram quando conheceram as User Defined Functions (UDFs) introduzidas nas versões modernas do COBOL Enterprise da IBM.

Durante décadas, quando precisávamos reutilizar lógica em COBOL, a solução era sempre a mesma:

  • CALL de subprograma

  • COPYBOOK

  • Macro

  • Módulos compartilhados

Funcionava.

Ainda funciona.

Mas o COBOL evoluiu.

E hoje o programador pode criar suas próprias funções, utilizá-las dentro de expressões e fazer chamadas tão elegantes quanto as funções nativas do compilador.

Sim.

Da mesma forma que você usa:

FUNCTION CURRENT-DATE

ou

FUNCTION UPPER-CASE(...)

você pode criar:

FUNCTION CALCULA-IR(...)

ou

FUNCTION VALIDA-CPF(...)

ou qualquer outra regra de negócio.

Para quem passou décadas trabalhando apenas com programas e subprogramas, isso parece quase magia.

Mas não é.

É apenas COBOL moderno.


Um Pouco de História

Nas versões clássicas do COBOL:

  • COBOL VS COBOL II

  • COBOL/370

  • COBOL for MVS

não existia conceito de função definida pelo usuário.

Tudo precisava ser feito através de:

CALL "ROTINA01"

O compilador não conhecia o conceito de retorno funcional.

Quando surgiram:

  • Enterprise COBOL V5

  • Enterprise COBOL V6

a IBM passou a suportar recursos alinhados ao padrão ISO COBOL moderno.

Entre eles:

User Defined Functions

ou simplesmente:

Funções Definidas pelo Usuário


O Que é Uma User Defined Function?

É um módulo COBOL especial que:

  • recebe parâmetros

  • processa dados

  • retorna um único valor

exatamente como uma função matemática.

Exemplo:

RESULTADO =
    FUNCTION DOBRO(VALOR)

Ao invés de:

CALL "DOBRO"

Quando Vale a Pena Utilizar?

Imagine uma regra utilizada em centenas de programas.

Por exemplo:

  • cálculo de imposto

  • cálculo de juros

  • validação de CPF

  • mascaramento de dados LGPD

  • formatação de código interno

Criar uma função centralizada reduz:

  • duplicação

  • manutenção

  • erros

e aumenta a legibilidade.


Estrutura de Uma Função COBOL

O segredo está na identificação.

Observe:

IDENTIFICATION DIVISION.

FUNCTION-ID. DOBRO.

Perceba:

Não usamos:

PROGRAM-ID

Usamos:

FUNCTION-ID

Isso transforma o módulo em uma função.


Exemplo Completo

Função DOBRO

       IDENTIFICATION DIVISION.
       FUNCTION-ID. DOBRO.

       DATA DIVISION.

       LINKAGE SECTION.

       01 LK-VALOR      PIC S9(9) COMP-5.

       01 RESULTADO     PIC S9(9) COMP-5.

       PROCEDURE DIVISION
            USING LK-VALOR
            RETURNING RESULTADO.

           COMPUTE RESULTADO =
                   LK-VALOR * 2

           GOBACK.

Simples.

Recebe:

LK-VALOR

Retorna:

RESULTADO

O RETURNING

A palavra-chave fundamental é:

RETURNING

Ela define o valor devolvido pela função.

Exemplo:

PROCEDURE DIVISION
    USING ENTRADA
    RETURNING SAIDA

Sem RETURNING não existe função.


Como Chamar a Função

Agora imagine um programa principal.

IDENTIFICATION DIVISION.
PROGRAM-ID. TESTE.

Working Storage

01 WS-NUMERO       PIC 9(4).
01 WS-RESULTADO    PIC 9(5).

Chamada

MOVE 10 TO WS-NUMERO

COMPUTE WS-RESULTADO =
        FUNCTION DOBRO(WS-NUMERO)

DISPLAY WS-RESULTADO

Resultado:

20

O Que o Compilador Faz?

Quando encontra:

FUNCTION DOBRO(...)

o compilador procura um módulo com:

FUNCTION-ID. DOBRO

e gera a ligação automaticamente.

É semelhante ao que acontece com:

FUNCTION CURRENT-DATE

Em Qual Biblioteca Deve Ser Gravado?

Aqui existe uma dúvida muito comum.

A função compilada gera um módulo objeto exatamente como qualquer outro programa COBOL.

Normalmente:

OBJETO

Vai para:

&&OBJ
SYSLIN

durante a compilação.


LOAD MODULE

Após o Link Edit:

LOADLIB

ou

STEPLIB

ou

USER.LOADLIB

dependendo dos padrões da empresa.

Exemplo:

PROD.COBOL.LOAD

ou

DEV.COBOL.LOAD

Que Tipo de Objeto é Criado?

Fisicamente o compilador gera:

Object Deck

OBJETO

e depois:

Program Object

ou

Load Module

dependendo da configuração do Binder.

Ou seja:

não existe um tipo especial de dataset para funções.

A função é armazenada como um módulo executável normal.

O diferencial está no:

FUNCTION-ID

Passo a Passo Completo

Passo 1

Criar o fonte.

Exemplo:

USER.COBOL(FDOBRO)

Passo 2

Codificar:

FUNCTION-ID. DOBRO.

Passo 3

Compilar.

Exemplo de JCL:

//COBOL EXEC IGYWCL

ou

//COB EXEC PROC=IGYWCLG

Dependendo do ambiente.


Passo 4

Gerar módulo em LOADLIB.

Exemplo:

USER.LOADLIB

Passo 5

Adicionar a LOADLIB na STEPLIB.

//STEPLIB DD DSN=USER.LOADLIB,

Passo 6

Compilar os programas consumidores.

O compilador localizará a função.


Funções Com Múltiplos Parâmetros

Exemplo:

FUNCTION-ID. SOMA2.

Linkage:

01 LK-N1 PIC S9(9).
01 LK-N2 PIC S9(9).

01 RETORNO PIC S9(9).

Procedure:

PROCEDURE DIVISION
    USING LK-N1 LK-N2
    RETURNING RETORNO.

    COMPUTE RETORNO =
        LK-N1 + LK-N2

    GOBACK.

Uso:

COMPUTE TOTAL =
        FUNCTION SOMA2(10,20)

Resultado:

30

Funções Podem Chamar Outras Funções

Sim.

Exemplo:

FUNCTION DOBRO(
    FUNCTION SOMA2(5,5))

Primeiro:

SOMA2 = 10

Depois:

DOBRO = 20

Muito parecido com linguagens modernas.


Funções Podem Ser Recursivas?

Sim.

Desde que o compilador permita:

RECURSIVE

e que a lógica esteja preparada.

Mas normalmente regras de negócio não exigem isso.


Diferença Entre CALL e FUNCTION

CALL

CALL "CALCULO"

Características:

  • múltiplos parâmetros

  • sem retorno obrigatório

  • paradigma tradicional


FUNCTION

FUNCTION CALCULO(...)

Características:

  • retorno explícito

  • pode participar de expressões

  • sintaxe mais elegante


Exemplo Real de Negócio

Imagine validar CPF.

Em vez de:

CALL "CPFVAL"

você pode escrever:

IF FUNCTION CPF-VALIDO(CPF)

Muito mais legível.

A regra passa a parecer uma instrução nativa da linguagem.


Opções de Compilação Recomendadas

Nas versões atuais do Enterprise COBOL V6.x é comum utilizar:

OPT(2)
ARCH(13)
RENT
LIST
MAP
XREF
SSRANGE

Em desenvolvimento:

SSRANGE

ajuda bastante na identificação de erros.

Em produção:

NOSSRANGE

para melhor desempenho.


Compatibilidade

As User Defined Functions fazem parte das versões modernas do COBOL Enterprise.

São suportadas nas famílias atuais:

  • Enterprise COBOL V5

  • Enterprise COBOL V6

  • z/OS modernos

Sempre confirme a versão instalada junto ao time de sistemas.


Ganho Arquitetural

O maior benefício não é técnico.

É arquitetural.

Você passa a criar uma verdadeira biblioteca corporativa de regras.

Imagine uma empresa com funções:

CALCULA-IR
CALCULA-IOF
VALIDA-CPF
VALIDA-CNPJ
FORMATA-CEP

Todas reutilizadas por centenas de programas.

O resultado é:

  • menos código duplicado

  • manutenção centralizada

  • maior padronização

  • menor risco operacional


A Grande Sacada

Durante quarenta anos aprendemos que reutilização em COBOL significava:

CALL

Mas o COBOL moderno adicionou uma camada muito mais elegante.

Hoje podemos construir verdadeiras APIs corporativas diretamente dentro da linguagem usando:

FUNCTION-ID

e consumi-las com:

FUNCTION nome-da-funcao(...)

Para o desenvolvedor que ainda programa como em 1995, isso parece um detalhe.

Para quem projeta sistemas corporativos gigantescos, isso é uma mudança de paradigma.

Porque, pela primeira vez, o COBOL permite encapsular regras de negócio reutilizáveis com a mesma simplicidade com que usamos CURRENT-DATE, UPPER-CASE ou LENGTH.

E é justamente aí que mora a ironia: milhares de profissionais continuam criando subprogramas para tudo, enquanto o compilador moderno já oferece uma forma muito mais elegante de transformar regras de negócio em funções reutilizáveis.

Em outras palavras, o COBOL não virou uma linguagem nova.

Mas aprendeu um truque que muitos veteranos ainda não descobriram. ☕💣🚀


quarta-feira, 15 de janeiro de 2025

☕📋💣 BACKLOG: O ARQUIVO SECRETO QUE SEPARA UM PROGRAMADOR COBOL COMUM DE UM VERDADEIRO ARQUITETO DE SISTEMAS

Bellacosa Mainframe e o backlog mainframe


☕📋💣 BACKLOG: O ARQUIVO SECRETO QUE SEPARA UM PROGRAMADOR COBOL COMUM DE UM VERDADEIRO ARQUITETO DE SISTEMAS

"O sistema não está parado. Ele apenas está esperando na fila."

Existe uma cena que se repete diariamente em praticamente todas as empresas que possuem Mainframe.

O telefone toca.

Um gerente aparece.

Um usuário reclama.

Um diretor pede urgência.

Uma área regulatória exige mudanças.

O banco central publica uma nova norma.

O auditor encontra uma inconsistência.

O operador identifica um erro.

E de repente surgem vinte novas tarefas.

A pergunta é:

quem decide o que será feito primeiro?

É exatamente nesse momento que nasce um dos conceitos mais importantes da engenharia de software moderna:

o Backlog.

Se você é um programador COBOL Mainframe iniciante, entender backlog pode acelerar sua carreira mais do que aprender cinquenta comandos novos de JCL.

Porque programar é importante.

Mas entender como o trabalho é organizado é o que diferencia um executor de um profissional estratégico.

Pegue seu café.

Vamos abrir esse dataset.


O QUE É BACKLOG?

A definição mais simples possível:

Backlog é uma lista organizada de tudo aquilo que precisa ser feito.

Simples assim.

Pode conter:

  • novas funcionalidades;

  • correções de bugs;

  • melhorias;

  • ajustes regulatórios;

  • documentação;

  • refatoração;

  • automação;

  • modernização.

Tudo entra no backlog.

Pense nele como uma fila de JOBs esperando para executar.


O BACKLOG EXPLICADO COMO UM JOB SCHEDULER

Imagine um ambiente de produção.

Você possui:

JOB001 - Fechamento diário
JOB002 - Atualização de clientes
JOB003 - Relatório gerencial
JOB004 - Backup
JOB005 - Auditoria

Todos precisam executar.

Mas existe uma ordem.

Backlog é exatamente isso.

Uma fila organizada de atividades aguardando execução.

A diferença é que em vez de JOBs estamos falando de trabalho humano.


O MAIOR MITO SOBRE BACKLOG

Muitos iniciantes acreditam:

"Backlog é uma lista de novas funcionalidades."

Errado.

Backlog é muito maior que isso.

Um backlog saudável contém:

  • inovação;

  • manutenção;

  • correções;

  • melhorias;

  • dívida técnica.

Quando só existem novas funcionalidades no backlog, algo está errado.

Muito errado.


UM EXEMPLO REAL DE MAINFRAME

Imagine um sistema bancário.

O backlog pode conter:

Criar PIX Internacional
Corrigir cálculo de juros
Atualizar layout FEBRABAN
Refatorar COBCLI01
Documentar JOB FAT0001
Criar testes para módulo de cobrança

Observe.

Nem tudo é desenvolvimento novo.

Parte do trabalho é manutenção.

Parte é prevenção.

Parte é sobrevivência.


ONDE ENTRA A DÍVIDA TÉCNICA?

Agora chegamos ao ponto interessante.

A dívida técnica normalmente vive dentro do backlog.

Por exemplo:

BACKLOG

Criar API de consulta
Novo relatório fiscal
Refatorar COBPAG01
Eliminar COPYBOOK duplicado
Automatizar testes

Os três últimos itens são pagamentos de dívida técnica.

Ou seja:

Todo pagamento de dívida técnica vira backlog.

Mas nem todo backlog é dívida técnica.


COMO A DÍVIDA TÉCNICA APARECE

Imagine que você recebeu uma demanda urgente.

O gerente diz:

"Precisamos colocar isso em produção amanhã."

Você cria uma solução rápida.

Funciona.

Entrega realizada.

Todo mundo feliz.

Meses depois:

  • ninguém entende o código;

  • faltam comentários;

  • surgem bugs;

  • novas alterações ficam lentas.

Pronto.

A dívida nasceu.


O EFEITO BOLA DE NEVE

O primeiro remendo parece inocente.

Depois vem outro.

E mais outro.

Então surge um IF dentro de outro IF.

Depois outro.

Quando você percebe:

IF A
   IF B
      IF C
         IF D
            IF E

O programa ainda funciona.

Mas ninguém mais entende.

Isso é o juros da dívida técnica.


O DIA EM QUE O BACKLOG VIROU UM CEMITÉRIO

Existe uma curiosidade interessante.

Algumas empresas possuem backlog com milhares de itens.

Mas ninguém sabe:

  • quem criou;

  • por que criou;

  • se ainda faz sentido.

Isso não é backlog.

É arqueologia corporativa.


COMO UM JÚNIOR DEVE ENXERGAR O BACKLOG

Não veja o backlog como uma lista de tarefas.

Veja como um mapa.

Ele mostra:

  • para onde o sistema está indo;

  • quais problemas existem;

  • quais riscos precisam ser tratados.

Os melhores analistas costumam estudar o backlog inteiro.

Não apenas sua tarefa.


COMO IDENTIFICAR DÍVIDA TÉCNICA

Existem sinais clássicos.

Programas gigantes

Mais de 10.000 linhas.


COPYBOOKs duplicados

Mesma estrutura espalhada.


JCLs clonados

Copiar e colar virou arquitetura.


Falta de documentação

Conhecimento armazenado apenas na cabeça de alguém.


Dependência de especialistas

Quando você ouve:

"Somente o Carlos entende isso."

A dívida já existe.


COMO MAPEAR DÍVIDA TÉCNICA

Crie uma planilha simples.

Campos:

  • Sistema

  • Programa

  • Problema

  • Risco

  • Complexidade

  • Prioridade

Exemplo:

ProgramaProblema
COBCLI01Sem documentação
COBPAG0215.000 linhas
COBFAT03Sem testes

Agora a dívida ficou visível.

E aquilo que é visível pode ser gerenciado.


MÉTRICAS IMPORTANTES

Os melhores profissionais medem.

Sempre.

Algumas métricas úteis:

Número de ABENDs

Quanto mais ABENDs.

Maior a chance de problemas estruturais.


Tempo médio de correção

Quanto demora para corrigir um incidente?


Quantidade de bugs

Excelente indicador.


Número de programas sem documentação

Métrica simples.

Mas extremamente poderosa.


FERRAMENTAS QUE AJUDAM

Muitos acreditam que Mainframe não possui ferramentas modernas.

Grande erro.


IBM ADDI

Mapeia dependências.

Mostra relações entre:

  • COBOL;

  • JCL;

  • DB2;

  • CICS.


IBM Application Discovery

Excelente para sistemas legados.


IBM Fault Analyzer

Investiga ABENDs.


IBM Debug Tool

Ajuda a entender programas complexos.


SonarQube

Em ambientes integrados.

Ajuda na análise de qualidade.


Git

Sim.

Mainframe moderno usa Git.

E muito.


COMO CONTROLAR O BACKLOG

Regra simples.

Prioridade.

Nem tudo tem o mesmo peso.

Uma técnica muito usada:

Alta prioridade

Produção parada.


Média prioridade

Risco futuro.


Baixa prioridade

Melhorias desejáveis.


O SEGREDO DOS TIMES MADUROS

Times iniciantes fazem:

100% Funcionalidades

Times maduros fazem:

70% Funcionalidades
20% Correções
10% Dívida Técnica

Alguns chegam a reservar uma sprint inteira para limpeza.

E os resultados aparecem rapidamente.


EASTER EGG MAINFRAME

Se você encontrar comentários como:

* NÃO ALTERAR
* FUNCIONA DESDE 1998

Você encontrou um fóssil corporativo.

Parabéns.

Agora investigue antes de tocar.

Porque muitas vezes esse comentário está escondendo uma dívida técnica de milhões de dólares.


A REGRA DOS 15 MINUTOS

Uma dica que poucos ensinam.

Se você gastou mais de 15 minutos para entender um trecho de código:

documente.

Seu "eu do futuro" agradecerá.


COMO EVOLUIR MAIS RÁPIDO NA CARREIRA

O júnior normalmente aprende:

  • COBOL;

  • JCL;

  • DB2;

  • CICS.

Mas os profissionais mais valorizados aprendem também:

  • gestão de backlog;

  • análise de impacto;

  • controle de dívida técnica;

  • arquitetura;

  • observabilidade.

É isso que os transforma em analistas seniores.


O QUE NINGUÉM CONTA SOBRE BACKLOG

O backlog é uma fotografia do estado de saúde do sistema.

Se ele possui:

  • centenas de bugs;

  • dezenas de refatorações pendentes;

  • documentação atrasada;

o sistema está acumulando dívida.

O backlog está contando uma história.

Aprenda a lê-la.


CONCLUSÃO

Backlog não é apenas uma lista de tarefas.

É o painel de controle do futuro do sistema.

E a dívida técnica é uma das passageiras mais perigosas dessa viagem.

Um programador COBOL Mainframe que aprende a:

  • identificar problemas;

  • registrar atividades;

  • priorizar demandas;

  • controlar dívida técnica;

  • documentar descobertas;

deixa de ser apenas alguém que escreve código.

Passa a ser alguém capaz de manter sistemas vivos por décadas.

E no mundo Mainframe, onde muitos programas são mais antigos que seus desenvolvedores, essa habilidade vale ouro.

Porque no final das contas, o verdadeiro segredo não é escrever um programa novo.

É conseguir entender por que aquele programa de 1989 ainda está funcionando perfeitamente em produção.

E sobreviver ao chamado das 03:17 da manhã quando alguém decidir alterá-lo.

 

sexta-feira, 29 de novembro de 2024

☕💣 O COBOL NÃO É BAGUNÇA: AS BOAS PRÁTICAS DE CODIFICAÇÃO QUE SEPARAM PROGRAMADORES DE MAINFRAME DE VERDADE DOS MEROS ESCREVEDORES DE CÓDIGO

Bellacosa Mainframe e o clean code no Cobol

☕💣 O COBOL NÃO É BAGUNÇA: AS BOAS PRÁTICAS DE CODIFICAÇÃO QUE SEPARAM PROGRAMADORES DE MAINFRAME DE VERDADE DOS MEROS ESCREVEDORES DE CÓDIGO

Durante décadas, o COBOL carregou uma fama injusta. Muitos profissionais associam a linguagem a programas gigantescos, difíceis de entender, cheios de GO TO, variáveis com nomes estranhos e regras de negócio espalhadas por milhares de linhas.

Mas existe uma verdade que poucos percebem:

O problema nunca foi o COBOL.

O problema sempre foi a forma como algumas pessoas escreveram COBOL.

Quando observamos sistemas modernos desenvolvidos em Enterprise COBOL para z/OS, encontramos recursos avançados, suporte a programação estruturada, funções intrínsecas, XML, JSON, tratamento de exceções e diversas funcionalidades que permitem criar aplicações extremamente organizadas e fáceis de manter.

Neste artigo vamos explorar as principais boas práticas de codificação para COBOL Mainframe, conceitos de Clean Code e técnicas utilizadas pelas equipes mais maduras do mercado.


Por que qualidade de código importa no Mainframe?

Em muitas empresas, um programa COBOL permanece em produção por décadas.

Enquanto uma aplicação web pode ser substituída em poucos anos, não é raro encontrar programas COBOL escritos nos anos 80 ou 90 ainda executando processos críticos.

Isso significa que:

  • O código será lido mais vezes do que escrito.

  • Diversos profissionais irão mantê-lo.

  • A regra de negócio precisa ser compreendida rapidamente.

  • Erros podem gerar impactos milionários.

Portanto, escrever código pensando apenas em "funcionar" é um erro.

O objetivo deve ser:

Funcionar hoje e continuar compreensível daqui a 20 anos.


O princípio mais importante: código deve parecer documentação

Um bom programa COBOL deve ser quase autoexplicativo.

Compare:

Exemplo ruim

IF A = 'S'
   MOVE '1' TO B
END-IF

Agora:

IF CLIENTE-ATIVO
   MOVE STATUS-APROVADO
      TO STATUS-CADASTRO
END-IF

No segundo caso, praticamente não é necessário comentário.

O código descreve o negócio.

Essa é uma das bases do Clean Code.


Utilize nomes significativos

Muitos sistemas antigos utilizam variáveis como:

01 WS-A.
01 WS-B.
01 WS-X.

Isso gera enorme dificuldade de manutenção.

Prefira:

01 WS-SALDO-CONTA.
01 WS-LIMITE-CREDITO.
01 WS-VALOR-SAQUE.

Uma boa regra:

Se o nome não explica o conteúdo, o nome está errado.


Padronize convenções de nomenclatura

Equipes maduras possuem padrões claros.

Exemplo:

WS- = Working Storage
LK- = Linkage
IN- = Entrada
OUT- = Saída
CNT- = Contador
FLG- = Flag

Exemplo:

01 WS-NOME-CLIENTE.
01 WS-IDADE-CLIENTE.
01 FLG-CLIENTE-ATIVO.

A simples leitura permite identificar a finalidade da variável.


Evite GO TO sempre que possível

Durante décadas o GO TO foi utilizado excessivamente.

Exemplo:

IF ERRO
   GO TO 9000-ERRO.

Embora ainda exista em muitos sistemas, o uso excessivo gera:

  • Fluxo confuso

  • Difícil rastreamento

  • Baixa manutenibilidade

Prefira:

IF ERRO
   PERFORM 9000-TRATAR-ERRO
END-IF

O PERFORM torna o fluxo muito mais previsível.


Use terminadores de escopo

Um dos maiores avanços do COBOL moderno foi a introdução dos terminadores explícitos.

Evite:

IF CLIENTE-ATIVO
   IF LIMITE-OK
      MOVE 'S' TO STATUS
ELSE
   MOVE 'N' TO STATUS

Prefira:

IF CLIENTE-ATIVO
   IF LIMITE-OK
      MOVE 'S' TO STATUS
   ELSE
      MOVE 'N' TO STATUS
   END-IF
END-IF

Terminações explícitas eliminam ambiguidades.


Mantenha parágrafos pequenos

Quando um parágrafo possui centenas de linhas, sua manutenção torna-se extremamente difícil.

Ruim:

1000-PROCESSAR.

com 500 linhas.

Melhor:

1000-PROCESSAR.

    PERFORM 1100-VALIDAR-DADOS
    PERFORM 1200-CALCULAR-TAXAS
    PERFORM 1300-ATUALIZAR-SALDOS
    PERFORM 1400-GERAR-RELATORIO.

Cada bloco possui responsabilidade específica.


Uma responsabilidade por parágrafo

Um erro comum é misturar atividades.

Exemplo:

2000-PROCESSAR.

faz:

  • leitura

  • validação

  • cálculo

  • gravação

  • relatório

Tudo junto.

Prefira dividir responsabilidades.

Isso segue o princípio conhecido como:

Single Responsibility Principle (SRP).


Evite código duplicado

Nada gera mais problemas do que duplicação.

Exemplo:

COMPUTE WS-VALOR =
        WS-VALOR * 1.15

copiado em 20 programas diferentes.

Quando a regra mudar, será necessário alterar os 20.

Melhor:

Criar uma rotina centralizada.

CALL 'CALCIMPO'

ou

PERFORM 5000-CALCULAR-IMPOSTO

Centralização reduz erros.


Comentários devem explicar o motivo, não o óbvio

Comentário ruim:

MOVE WS-NOME
 TO WS-NOME-SAIDA

Comentário:

* Move o nome para saída

Isso não agrega valor.

Comentário bom:

* Regra exigida pelo Banco Central
* Circular 3456/2024

Explica o motivo da regra.


Organize o programa em camadas lógicas

Uma estrutura clássica é:

IDENTIFICATION DIVISION

ENVIRONMENT DIVISION

DATA DIVISION

PROCEDURE DIVISION

0000-MAIN

1000-INICIALIZAR

2000-LER-ARQUIVO

3000-PROCESSAR

4000-GRAVAR

9000-FINALIZAR

Essa organização ajuda qualquer programador a navegar rapidamente pelo código.


Utilize COPYBOOKS adequadamente

Copybooks são excelentes para reutilização.

Exemplo:

COPY CLIENTE.

Benefícios:

  • Padronização

  • Reutilização

  • Menor manutenção

Mas cuidado:

Não transforme copybooks em monstros de milhares de linhas.


Trate erros explicitamente

Um programa profissional nunca assume sucesso.

Errado:

READ ARQ-CLIENTE

Melhor:

READ ARQ-CLIENTE
   AT END
      SET FIM-ARQUIVO TO TRUE
END-READ

Ou:

EXEC SQL
    SELECT ...
END-EXEC

IF SQLCODE NOT = ZERO
    PERFORM 9000-TRATAR-ERRO
END-IF

Nunca ignore SQLCODE

Em ambientes DB2 esta regra é sagrada.

Após cada comando SQL:

IF SQLCODE = 0

ou

EVALUATE TRUE
   WHEN SQLCODE = 0
   WHEN SQLCODE = 100
   WHEN OTHER
END-EVALUATE

Ignorar SQLCODE é abrir espaço para falhas silenciosas.


Prefira EVALUATE ao invés de IFs excessivos

Ruim:

IF TIPO = 'A'
...
ELSE
   IF TIPO = 'B'
...

Melhor:

EVALUATE TIPO
   WHEN 'A'
      ...
   WHEN 'B'
      ...
   WHEN 'C'
      ...
   WHEN OTHER
      ...
END-EVALUATE

Mais legível e mais fácil de expandir.


Utilize variáveis booleanas (88 Level)

Um recurso poderoso e subutilizado.

01 WS-STATUS.
   05 WS-COD-STATUS PIC X.

88 CLIENTE-ATIVO VALUE 'A'.
88 CLIENTE-INATIVO VALUE 'I'.

Uso:

IF CLIENTE-ATIVO

Muito melhor que:

IF WS-COD-STATUS = 'A'

Reduza dependências externas

Quanto mais dependências:

  • Mais acoplamento

  • Mais manutenção

  • Mais risco

Sempre avalie:

"Essa chamada realmente é necessária?"


Mantenha consistência visual

Exemplo:

MOVE WS-NOME
   TO WS-NOME-SAIDA

ADD WS-VALOR
   TO WS-TOTAL

PERFORM 3000-PROCESSAR

Código alinhado facilita leitura.

A produtividade da manutenção aumenta significativamente.


Evite números mágicos

Ruim:

IF WS-IDADE > 18

Melhor:

78 IDADE-MINIMA VALUE 18.

IF WS-IDADE > IDADE-MINIMA

A regra fica documentada.


Faça validações no início

Evite processar dados inválidos.

Exemplo:

IF WS-CPF = SPACES
   PERFORM 9000-ERRO
   GO TO 9999-SAIDA
END-IF

Falhar cedo reduz complexidade.


Desenvolva pensando em testes

Uma boa prática moderna é escrever código facilmente testável.

Rotinas menores:

1100-VALIDAR
1200-CALCULAR
1300-GERAR

permitem testes independentes.


Registre logs úteis

Logs não devem apenas indicar erro.

Exemplo:

Cliente 12345 rejeitado.
Motivo: Limite insuficiente.

Informação útil reduz tempo de diagnóstico.


Utilize recursos modernos do COBOL

Muitos programadores ainda escrevem COBOL como nos anos 80.

Entretanto o Enterprise COBOL oferece:

  • Functions

  • Inline Perform

  • Scope Terminators

  • XML PARSE

  • JSON PARSE

  • JSON GENERATE

  • Intrinsic Functions

  • UTF-8

  • National Data

Utilizar recursos modernos aumenta produtividade e legibilidade.


Revise código antes de promover

Code Review é uma das melhores práticas existentes.

Benefícios:

  • Detecta defeitos

  • Padroniza estilo

  • Compartilha conhecimento

  • Melhora qualidade

Nenhum profissional experiente deveria temer revisão.


Métricas que valem a pena acompanhar

Alguns indicadores importantes:

  • Complexidade ciclomática

  • Linhas por módulo

  • Cobertura de testes

  • Duplicação de código

  • Defeitos em produção

O que é medido tende a melhorar.


O verdadeiro significado de Clean Code no Mainframe

Muitos acreditam que Clean Code é apenas uma moda criada para Java ou aplicações web.

Não é.

Clean Code significa:

  • Clareza

  • Simplicidade

  • Legibilidade

  • Manutenibilidade

  • Organização

Esses princípios são universais.

Eles funcionam tão bem em COBOL quanto em qualquer linguagem moderna.


Conclusão

O mercado frequentemente discute modernização de aplicações, APIs, cloud e inteligência artificial. Entretanto, poucas empresas percebem que a maior modernização possível muitas vezes começa dentro do próprio código COBOL.

Um programa limpo reduz custos, diminui defeitos, acelera manutenções e facilita a transferência de conhecimento entre gerações de profissionais.

O COBOL moderno oferece todos os recursos necessários para produzir software elegante, estruturado e sustentável.

A diferença entre um sistema que sobrevive décadas com qualidade e outro que se transforma em um pesadelo operacional não está na linguagem utilizada.

Está na disciplina de engenharia aplicada por quem escreve o código.

E essa disciplina continua sendo uma das habilidades mais valiosas de qualquer profissional de Mainframe.

Título alternativo para maior engajamento em blog/newsletter:

☕💣 SEU COBOL FUNCIONA... MAS ALGUÉM CONSEGUE ENTENDER? AS 25 REGRAS DE CLEAN CODE QUE TODO PROGRAMADOR MAINFRAME DEVERIA SEGUIR ANTES DA PRÓXIMA PROMOÇÃO PARA PRODUÇÃO


terça-feira, 2 de janeiro de 2024

☕💣🔥 O DIA EM QUE 10.000 USUÁRIOS DERRUBARAM UM COBOL QUE FUNCIONAVA PERFEITAMENTE — O GUIA DEFINITIVO DE TESTES DE PERFORMANCE PARA O PADAWAN DO MAINFRAME

Bellacosa Mainframe e a performance em mainframe


☕💣🔥 O DIA EM QUE 10.000 USUÁRIOS DERRUBARAM UM COBOL QUE FUNCIONAVA PERFEITAMENTE — O GUIA DEFINITIVO DE TESTES DE PERFORMANCE PARA O PADAWAN DO MAINFRAME

Existem algumas frases que assustam qualquer profissional experiente de Mainframe.

Uma delas é:

"Pode colocar em produção. Já testamos tudo."

A segunda é:

"Funcionou na minha máquina."

E a terceira, talvez a mais perigosa de todas:

"Performance a gente vê depois."

Se você é um jovem Padawan do COBOL, provavelmente acredita que o trabalho do programador termina quando o programa compila sem erros, passa nos testes funcionais e devolve o resultado correto.

Mas existe um mundo oculto além da lógica.

Um universo onde programas corretos derrubam bancos.

Onde APIs perfeitamente desenvolvidas travam durante a Black Friday.

Onde um SELECT aparentemente inocente consegue transformar uma aplicação inteira em um incêndio corporativo.

Esse universo chama-se Performance.

E hoje vamos conversar sobre um assunto que separa programadores comuns dos profissionais que sobrevivem décadas trabalhando em ambientes críticos.

Vamos falar sobre Testes de Performance.


A PRIMEIRA GRANDE LIÇÃO

Imagine que você criou um programa COBOL chamado CONSULTA-SALDO.

O programa recebe:

  • Agência

  • Conta

Consulta o DB2.

Retorna o saldo.

Você testa.

Funciona.

Seu colega testa.

Funciona.

O analista testa.

Funciona.

O gerente testa.

Funciona.

Todo mundo comemora.

O programa sobe para produção.

Cinco minutos depois:

O Internet Banking trava.

O aplicativo móvel trava.

O atendimento telefônico trava.

O gerente da agência liga desesperado.

E você pensa:

"Mas aqui funcionava..."

Sim.

Funcionava.

Para um usuário.

Produção não possui um usuário.

Produção possui milhares.

Essa é a primeira lição da performance.

Um sistema que funciona para uma pessoa não necessariamente funciona para dez mil.


O QUE É UM TESTE DE PERFORMANCE?

Muitos iniciantes acreditam que teste de performance significa medir velocidade.

Não é apenas isso.

Teste de performance é a arte de descobrir como um sistema se comporta quando submetido ao mundo real.

Queremos responder perguntas como:

  • Quantos usuários suporta?

  • Qual o tempo de resposta?

  • Onde está o gargalo?

  • Quanto de CPU consome?

  • Quanto de memória utiliza?

  • Quantas transações por segundo processa?

Na prática estamos tentando descobrir o limite antes que o cliente descubra primeiro.

Porque quando o cliente descobre primeiro, normalmente já existe uma crise instalada.


TESTES FUNCIONAIS X TESTES NÃO FUNCIONAIS

O material apresentado faz uma separação extremamente importante.

Testes funcionais verificam:

"O sistema faz o que deveria fazer?"

Exemplo:

Você informa uma conta.

O sistema retorna o saldo correto.

Teste aprovado.

Mas existe outra pergunta.

"O sistema continua fazendo isso quando dez mil usuários acessam simultaneamente?"

Essa pergunta pertence ao mundo dos testes não funcionais.

E é exatamente aqui que entra a performance.


O EXEMPLO DO AUTOMÓVEL

Imagine um carro.

Você gira a chave.

O motor liga.

Teste funcional aprovado.

Mas ainda faltam várias perguntas:

  • Qual a velocidade máxima?

  • Quanto consome?

  • Quanto suporta de carga?

  • Como se comporta em uma subida?

  • Como reage após cinco horas de viagem?

Essas perguntas representam os testes não funcionais.

O mesmo vale para sistemas.


O QUE REALMENTE DERRUBA SISTEMAS?

O Padawan normalmente pensa:

"Se estiver lento é porque falta CPU."

Nem sempre.

Na verdade, CPU costuma ser apenas um dos suspeitos.

Os verdadeiros vilões geralmente são:

  • SQL mal escrito

  • Índices ausentes

  • Locks excessivos

  • Filas MQ congestionadas

  • Chamada excessiva a serviços

  • Pool JDBC esgotado

  • Recursos compartilhados

Em outras palavras:

O problema normalmente não está onde você imagina.


TESTE DE CARGA

Este é o mais conhecido.

O objetivo é reproduzir o uso normal esperado.

Imagine:

O banco estima 5.000 usuários simultâneos.

Criamos então um cenário simulando exatamente esse volume.

A pergunta é simples:

"O sistema suporta?"

Se suporta, ótimo.

Se não suporta, ainda temos tempo para corrigir.

Muito melhor descobrir isso no laboratório do que no Jornal Nacional.


TESTE DE ESTRESSE

Aqui a conversa fica interessante.

Em vez de testar o limite esperado, ultrapassamos o limite.

Muito.

Se o ambiente foi projetado para 5.000 usuários:

Testamos 10.000.

15.000.

20.000.

Queremos descobrir:

Como ele falha?

Uma falha controlada é muito melhor que um colapso inesperado.


TESTE DE RESISTÊNCIA

Agora imagine uma maratona.

O sistema suporta 5.000 usuários.

Ótimo.

Mas por quanto tempo?

Uma hora?

Duas?

Dez?

Vinte e quatro?

O teste de resistência mantém carga constante durante longos períodos.

Muitas aplicações parecem saudáveis por trinta minutos.

Depois começam a consumir memória.

Depois mais memória.

Depois ainda mais memória.

Até morrerem lentamente.

É o famoso Memory Leak.


TESTE DE PICO

Imagine a abertura das vendas de um show.

Ou a Black Friday.

Ou o lançamento de um PIX promocional.

O tráfego explode.

O sistema precisa absorver esse impacto.

O teste de pico verifica exatamente isso.

O comportamento durante explosões repentinas.


O MUNDO HÍBRIDO

Antigamente era simples.

Usuário.

Tela.

Mainframe.

Fim.

Hoje não.

Hoje temos:

Aplicativo Mobile

Apache

WebSphere

API Gateway

Microsserviços

MQ

CICS

COBOL

DB2

Percebe o problema?

Se a tela demora cinco segundos, onde está o gargalo?

Pode estar em qualquer ponto da cadeia.

E é por isso que observabilidade se tornou tão importante.


APACHE JMETER

Se existe uma ferramenta que virou símbolo dos testes de carga modernos, essa ferramenta é o Apache JMeter.

Pense nele como um exército virtual.

Você configura usuários fictícios.

Esses usuários começam a executar operações.

Consultar saldo.

Fazer transferência.

Emitir extrato.

Pagar boleto.

E o sistema acredita que são usuários reais.

O JMeter consegue gerar milhares de acessos simultâneos.

É exatamente assim que simulamos produção sem colocar clientes reais em risco.


EXEMPLO PRÁTICO

Suponha uma API:

GET /saldo

Queremos simular:

5.000 usuários.

Criamos:

Thread Group

Usuários: 5000

Ramp-Up: 300 segundos

Loop: infinito

Agora adicionamos:

HTTP Request

Executamos.

Pronto.

Começamos a produzir carga.

Mas isso é apenas metade da história.


POR QUE APENAS GERAR CARGA NÃO BASTA?

Imagine um médico.

Ele mede sua pressão.

Mas ignora:

  • Frequência cardíaca

  • Oxigenação

  • Temperatura

Seria um diagnóstico completo?

Claro que não.

Com performance ocorre a mesma coisa.

Gerar carga é apenas o começo.

Precisamos observar o ambiente inteiro.


DYNATRACE

É aqui que entra o Dynatrace.

Pense nele como uma tomografia computadorizada da aplicação.

Ele acompanha cada requisição.

Cada chamada.

Cada serviço.

Cada banco de dados.

Cada microsserviço.

Cada transação.

Em vez de simplesmente dizer:

"Está lento."

Ele mostra:

"Está lento porque o Serviço X chamou o Serviço Y que executou uma consulta SQL custosa."

Agora existe informação para agir.


O SONHO DE TODO ANALISTA DE PERFORMANCE

Imagine um clique no aplicativo.

Consultar saldo.

Dynatrace exibe:

Frontend = 80 ms

API = 100 ms

Microsserviço = 120 ms

CICS = 800 ms

DB2 = 700 ms

Pronto.

Achamos o culpado.

Não existe mais adivinhação.


GRAFANA

Se Dynatrace é o médico.

Grafana é o painel da UTI.

Ele transforma números em gráficos.

Mostra:

  • CPU

  • Memória

  • Throughput

  • Erros

  • Tempo médio

  • Percentil 95

  • Percentil 99

E permite acompanhar tudo em tempo real.

Uma imagem muitas vezes vale mais que mil relatórios.


O QUE O MAINFRAME ENSINA SOBRE PERFORMANCE?

Muito antes da palavra observabilidade virar moda, o Mainframe já monitorava tudo.

E quando digo tudo, é tudo mesmo.

O z/OS nasceu para ambientes críticos.

Por isso existem ferramentas extremamente sofisticadas.


SMF

System Management Facility.

Registra praticamente tudo.

CPU.

I/O.

Transações.

Consumo.

Execução.

É o grande livro de registros do sistema.


RMF

Resource Measurement Facility.

Analisa comportamento dos recursos.

Ajuda a identificar gargalos.

Mostra utilização de processadores.

Filas.

Memória.

Dispositivos.


OMEGAMON

Uma das ferramentas mais famosas do universo IBM.

Monitora:

  • z/OS

  • CICS

  • DB2

  • MQ

Em tempo real.

Quando algo fica lento, geralmente ele é um dos primeiros lugares onde o especialista procura respostas.


O MAIOR ERRO DOS PROGRAMADORES INICIANTES

O Padawan costuma pensar:

"Meu programa executa rápido."

Mas rápido para quem?

Com qual volume?

Em qual horário?

Contra qual banco?

Com quantos registros?

Essas perguntas mudam tudo.

Um SELECT que retorna dez linhas parece maravilhoso.

O mesmo SELECT retornando dez milhões de linhas pode virar um desastre.


O CASO DO LOOP INOCENTE

Imagine:

PERFORM UNTIL EOF

READ ARQUIVO

PROCESSA

END-PERFORM

Parece simples.

Mas e se o arquivo possuir:

50 milhões de registros?

Agora o cenário muda.

Performance não depende apenas do código.

Depende dos dados.


PERFORMANCE É ARQUITETURA

Muitos acreditam que performance é responsabilidade exclusiva da infraestrutura.

Não é.

Também não é responsabilidade exclusiva do desenvolvedor.

Performance é responsabilidade de todos.

Arquitetura.

Banco.

Infraestrutura.

Rede.

Aplicação.

Integração.

Monitoramento.

Tudo influencia.


A MENTALIDADE DO PROFISSIONAL MADURO

O iniciante pergunta:

"Funciona?"

O profissional experiente pergunta:

"Funciona sob carga?"

O iniciante pergunta:

"Retornou o resultado?"

O profissional experiente pergunta:

"Quanto tempo demorou?"

O iniciante pergunta:

"Passou no teste?"

O profissional experiente pergunta:

"Qual foi o consumo?"

Essa mudança de mentalidade transforma carreiras.


A LIÇÃO FINAL

Ao longo dos anos vi programas COBOL sobreviverem décadas.

Vi sistemas processarem bilhões de transações.

Vi ambientes suportarem eventos gigantescos sem falhar.

E todos tinham algo em comum.

Performance não era tratada como um detalhe.

Era tratada como requisito.

Porque funcionalidades atraem usuários.

Mas é a performance que permite que eles permaneçam utilizando o sistema.

No fim das contas, um programa COBOL não é avaliado apenas pelo que faz.

Ele é avaliado pela velocidade, estabilidade e capacidade com que faz aquilo.

E essa é a diferença entre escrever código e construir sistemas capazes de sobreviver ao mundo real.

Bem-vindo ao próximo nível da sua jornada no Mainframe, jovem Padawan.

Agora você já sabe que compilar é apenas o começo.