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

Translate

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

domingo, 26 de julho de 2026

Os Três Bugs Invisíveis do Padawan COBOL : Como vencer a hesitação, a ingenuidade e o excesso de confiança

Bellacosa Mainframe e os 3 bugs invisiveis do padawan cobol



☕ Um Café no Bellacosa Mainframe

Os Três Bugs Invisíveis do Padawan COBOL

Como vencer a hesitação, a ingenuidade e o excesso de confiança antes que eles provoquem o primeiro ABEND da sua carreira

"O primeiro programa raramente derruba o banco. O primeiro erro de julgamento, sim."


Introdução

Existe um momento curioso na carreira de praticamente todo programador COBOL.

Não importa se ele estudou durante seis meses, um ano ou cinco anos.

Não importa se tirou certificações IBM.

Não importa se domina PROCEDURE DIVISION, PERFORM VARYING, OCCURS DEPENDING ON, SQL EMBEDDED, CICS ou VSAM.

O verdadeiro teste começa no primeiro dia em produção.

É ali que nasce o verdadeiro programador.

Durante décadas observando profissionais entrando em grandes bancos, seguradoras, empresas aéreas, órgãos públicos e processadoras de cartões, percebi um padrão curioso.

Os novatos quase nunca fracassam por falta de conhecimento técnico.

Eles tropeçam em três inimigos invisíveis.

São eles:

  • Hesitação

  • Ingenuidade

  • Excesso de confiança

Esses três defeitos aparecem em praticamente toda profissão crítica.

Na aviação.

Na medicina.

Na engenharia.

Na investigação criminal.

E, principalmente, em ambientes IBM Mainframe.

O curioso é que eles aparecem em momentos diferentes da evolução profissional.

E quase sempre na mesma ordem.

Hoje vamos investigar cada um deles como se estivéssemos em um episódio de CSI.

Porque um sistema crítico deixa rastros.

E a mente do programador também.


Cena do Crime 1

A Hesitação

Imagine a seguinte situação.

Você acabou de entrar na empresa.

Seu líder diz:

"Precisamos alterar o programa FINA340."

Você abre o programa.

28.000 linhas.

Escrito em 1989.

Última alteração:
há quatro dias.

Autores:

  • João

  • Carlos

  • Equipe Y2K

  • Projeto PIX

  • Open Banking

  • Adequação LGPD

Você olha aquilo.

O cursor pisca.

Cinco minutos.

Dez minutos.

Quinze minutos.

Você simplesmente não consegue tocar em nada.

Isso é completamente normal.


O cérebro entra em modo de sobrevivência

Nosso cérebro odeia destruir algo que parece importante.

Quanto maior a responsabilidade...

Maior a hesitação.

É um mecanismo biológico.

O problema é que hesitação excessiva paralisa.

E um programador parado não aprende.


O primeiro segredo

Veteranos não têm menos medo.

Eles apenas sabem investigar antes.

Essa é uma diferença gigantesca.

O novato pensa:

"Vou alterar."

O veterano pensa:

"Vou entender."


O método Bellacosa

Nunca altere antes de responder:

O que este programa faz?

Quem chama este programa?

Quem ele chama?

Quais arquivos atualiza?

Quais tabelas Db2 altera?

Existe rollback?

Existe commit?

Existe checkpoint?

Existe controle de versão?

Existe scheduler?

Existe impacto batch?

Existe impacto online?

Existe interface MQ?

Existe interface CICS?

Existe API?

Quando todas essas respostas aparecem...

A hesitação desaparece.

Porque ela foi substituída por conhecimento.


Easter Egg

Sherlock Holmes dizia:

"É um erro teorizar antes de possuir os fatos."

Todo programador COBOL deveria colocar essa frase no monitor.


Cena do Crime 2

A Ingenuidade

Depois do primeiro mês...

A hesitação diminui.

Agora nasce outro inimigo.

O iniciante acredita em tudo.

Documentação.

Comentários.

Fluxogramas.

Diagramas.

PowerPoint.

Wiki.

Chamados.

Manuais.


A maior mentira do Mainframe

Imagine encontrar isso:

* Atualiza somente clientes ativos

Bonito.

Organizado.

Profissional.

Mas você olha o código...

MOVE "S" TO WS-ATIVO

Nada mais.

Nenhuma validação.

Nenhuma regra.

Nenhum IF.

O comentário está errado há quinze anos.

Quem escreveu?

Provavelmente alguém que saiu da empresa em 2004.


A documentação envelhece

Código muda.

Documentação nem sempre.

O sistema continua funcionando.

Mas o documento virou arqueologia.

É como encontrar um mapa romano tentando dirigir em São Paulo.


A regra de ouro

Nunca confie totalmente em:

Comentários

Diagramas

Documentação

Fluxogramas

Apresentações

Emails antigos

Confie no comportamento do sistema.

Ele não mente.


Curiosidade

Muitos bancos possuem documentação cuja última atualização ocorreu antes do PIX existir.

O sistema evoluiu.

O documento não.


Cena do Crime 3

O Excesso de Confiança

Esse é o mais perigoso.

Porque normalmente aparece depois dos primeiros sucessos.

Você já resolveu alguns chamados.

Corrigiu ABEND.

Alterou tela CICS.

Fez alguns programas.

Agora pensa:

"Estou dominando."

É aí que mora o perigo.


O efeito Dunning-Kruger no Mainframe

Existe um fenômeno psicológico famoso.

Quanto menos sabemos...

Mais acreditamos saber.

Depois de alguns anos...

Percebemos o tamanho do universo.

É curioso.

O profissional de cinco meses costuma parecer mais confiante que o de vinte anos.

Porque ainda não descobriu tudo o que desconhece.


O veterano faz mais perguntas

O iniciante responde rápido.

O veterano pergunta mais.

Isso parece contraditório.

Mas faz sentido.

O veterano conhece centenas de armadilhas.

Ele sabe que sistemas críticos escondem surpresas.


Exemplo clássico

Você altera:

IF SALDO > 0

Parece simples.

Mas esquece que existe outro programa batch.

Outro online.

Outro scheduler.

Outro MQ.

Outro API Gateway.

Outro processo noturno.

Outro job semanal.

Outro fechamento mensal.

Outro processamento anual.

Seu IF alterou uma cadeia inteira.


O código nunca vive sozinho

Essa talvez seja a maior descoberta da carreira.

Programas COBOL não são ilhas.

São organismos.

Cada programa conversa com dezenas de outros.

Às vezes centenas.

Você altera uma linha.

Pode movimentar uma cidade inteira.


CSI Mainframe

Imagine Gil Grissom entrando no CPD.

Ele nunca começaria perguntando:

"Quem é o culpado?"

Ele perguntaria:

"O que aconteceu primeiro?"

Depois:

"O que mudou?"

Depois:

"Quem foi impactado?"

É exatamente assim que um analista experiente investiga incidentes.


Indiana Jones no Data Center

O código legado lembra uma cidade perdida.

Você entra com uma tocha.

Cada COPYBOOK é uma sala.

Cada PERFORM é um corredor.

Cada CALL é uma porta secreta.

Cada JCL é um mapa.

Cada PROC é um túnel subterrâneo.

E cada alteração pode ativar uma armadilha escondida.

O aventureiro imprudente corre.

O arqueólogo observa.


A Regra dos Cinco "Por Quês"

Sempre pergunte:

Por que isso existe?

Por que foi escrito assim?

Por que não removeram?

Por que ainda funciona?

Por que ninguém mexe nisso?

A quinta resposta normalmente revela uma decisão de negócio esquecida.


O Erro Mais Caro

Não é apagar um arquivo.

Nem provocar um ABEND.

Nem esquecer um END-IF.

O erro mais caro é assumir.

Assumir que entendeu.

Assumir que ninguém usa.

Assumir que é simples.

Assumir que o comentário está correto.

Assumir que aquele campo nunca recebe zeros.

Mainframe odeia suposições.


O Poder da Humildade Técnica

Existe uma frase muito comum entre grandes especialistas IBM.

"Não sei. Vamos verificar."

Observe.

Eles não respondem imediatamente.

Eles investigam.

Essa postura não demonstra fraqueza.

Demonstra maturidade.


O Ritual Bellacosa Antes de Alterar Qualquer Programa

Criei ao longo dos anos um pequeno ritual que evita boa parte dos problemas em produção. Antes de salvar qualquer alteração, faça estas perguntas:

  1. Entendi exatamente qual é o problema de negócio?

  2. Descobri todos os programas envolvidos?

  3. Verifiquei os COPYBOOKs relacionados?

  4. Analisei impactos em Db2, VSAM, CICS ou IMS?

  5. Procurei alterações semelhantes no histórico?

  6. Executei testes com dados normais e dados extremos?

  7. Pensei no que acontece se um campo vier vazio, nulo ou inesperado?

  8. Existe plano de retorno (rollback) caso algo dê errado?

  9. Alguém mais experiente revisou minha lógica?

  10. Eu conseguiria explicar esta alteração para outra pessoa em cinco minutos?

Se alguma resposta for "não", ainda há investigação a fazer.


Os Três Mestres da Carreira

Todo grande profissional aprende a equilibrar três características:

Coragem
Para enfrentar programas enormes sem fugir.

Curiosidade
Para investigar antes de alterar.

Humildade
Para aceitar que sempre existe algo escondido no sistema.

Esses três pilares são muito mais importantes do que decorar todas as instruções do COBOL.


O Último Easter Egg

Na saga Star Wars, Luke Skywalker acreditava que vencer significava lutar melhor.

Yoda ensinou outra coisa.

Primeiro, controlar a própria mente.

Só depois controlar o sabre de luz.

No Mainframe acontece exatamente o mesmo.

O COBOL não é o sabre.

O sabre é apenas uma ferramenta.

O verdadeiro combate acontece dentro da cabeça do programador.

A hesitação precisa ser transformada em investigação.

A ingenuidade precisa ser substituída por validação.

O excesso de confiança precisa dar lugar à disciplina.

Quando isso acontece, nasce um profissional capaz de trabalhar em ambientes onde milhões de transações financeiras, folhas de pagamento, benefícios governamentais, seguros, cartões de crédito e operações bancárias dependem de algumas linhas de código escritas décadas atrás.


Conclusão — O Primeiro Grande Upgrade Não é no Código, é no Programador

No universo Bellacosa Mainframe, costumo dizer que existem dois tipos de iniciantes.

O primeiro acredita que aprender COBOL significa memorizar verbos, comandos, JCLs e utilitários. Ele mede seu progresso pela quantidade de sintaxes que conhece.

O segundo entende que COBOL é apenas a linguagem usada para conversar com um ecossistema gigantesco de regras de negócio, processos, integrações e pessoas. Ele mede seu progresso pela qualidade das perguntas que faz, pela capacidade de investigar antes de modificar e pela prudência ao assumir responsabilidades.

É esse segundo profissional que evolui para analista, arquiteto, líder técnico e mentor.

A verdadeira iniciação de um Padawan Mainframe não acontece quando ele compila seu primeiro programa sem erros. Ela acontece no dia em que percebe que um sistema legado é como um templo antigo: cada rotina foi construída por gerações diferentes, cada COPYBOOK guarda um pedaço da história da empresa e cada linha de código existe por um motivo — mesmo que esse motivo tenha sido esquecido pelo tempo.

Se você conseguir vencer a hesitação sem perder a prudência, abandonar a ingenuidade sem perder a curiosidade e controlar o excesso de confiança sem perder a coragem, terá desenvolvido a característica mais valiosa de todas: o julgamento técnico.

E julgamento técnico não se aprende em um manual. Ele é construído a cada investigação, a cada revisão de código, a cada incidente resolvido e a cada lição deixada por um erro.

No fim das contas, o maior sistema que um programador COBOL precisa aprender a administrar não é o z/OS, o CICS ou o Db2.

É a própria mente. Só quando ela trabalha de forma disciplinada, investigativa e humilde é que o restante do ecossistema Mainframe deixa de parecer um labirinto e passa a revelar sua verdadeira arquitetura. Nesse momento, o Padawan deixa de apenas escrever programas e começa, de fato, a pensar como um guardião dos sistemas que sustentam parte da economia do mundo.

terça-feira, 21 de julho de 2026

Batman, Robin e o Mainframe : Como um Desenvolvedor COBOL Entra em um IBM Z pela Primeira Vez sem Acionar o Bat-Sinal do Operador

 

Bellacosa Mainframe o mainframe na batcaverna

☕ Um Café no Bellacosa Mainframe

Batman, Robin e o Mainframe

Como um Desenvolvedor COBOL Entra em um IBM Z pela Primeira Vez sem Acionar o Bat-Sinal do Operador


Conheça o Bat-computer dos anos 1960

https://youtu.be/uTf1wuKf65w

Conteúdo

✔ O que acontece quando o operador liga o computador (IPL)

✔ O nascimento do z/OS

✔ Como JES2 acorda o Data Center

✔ Por que ninguém entra diretamente no COBOL

✔ TSO explicado como se fosse a Batcaverna

✔ O Menu Principal do ISPF

✔ O que faz cada opção

  • Option 0
  • Option 1
  • Option 2
  • Option 3
  • Option 4
  • Option 6
  • Option 7
  • Option 9
  • SDSF

A jornada completa

POWER ON

      │

      ▼

     IPL

      │

      ▼

    z/OS

      │

      ▼

    JES2

      │

      ▼

    RACF

      │

      ▼

 LOGIN

      │

      ▼

     TSO

      │

      ▼

    ISPF

      │

      ▼

EDIT COBOL

      │

      ▼

COMPILE

      │

      ▼

LINK

      │

      ▼

RUN

      │

      ▼

SDSF

      │

      ▼

OUTPUT

O Menu Principal do ISPF explicado como uma Batcaverna

Cada opção será comparada a um equipamento do Batman.

Exemplo:

Option 2 – EDIT

"É o laboratório onde Bruce Wayne modifica seus gadgets.

Aqui você modifica programas COBOL, JCL, PROC, CLIST, REXX, membros PDS, datasets inteiros.

Se Alfred fosse programador, passaria metade da vida aqui."


Comandos TSO essenciais

LISTCAT

ALLOC

FREE

PROFILE

LISTDS

DELETE

RENAME

COPY

RECEIVE

TRANSMIT

OUTTRAP

EXEC

LOGOFF

TIME

HELP

LISTA

STATUS

E dezenas de exemplos.


Editando programas

LINHAS

COLUNAS

PREFIX

A

B

C

M

MM

CC

RR

OO

DD

CUT

PASTE

UNDO

RECOVER

HEX ON

COLS

RESET

FIND

CHANGE

LOCATE

RFIND

RCHANGE


Trabalhando com datasets

PDS

PDSE

SEQ

VSAM

Como copiar

Como renomear

Como mover

Como comparar

Como fazer backup


FTP no Mainframe

FTP tradicional

IND$FILE

Download

Upload

Modo ASCII

Modo Binary

Erros comuns


O ciclo completo do desenvolvedor COBOL

Editar

Salvar

Compilar

Analisar erros

Corrigir

Recompilar

Executar

Analisar SYSOUT

Consultar SDSF

Localizar ABEND

Corrigir

Repetir


O que aparece no SDSF

ST

DA

I

O

LOG

H

JESMSGLG

JESJCL

SYSOUT

OUTPUT

Como interpretar tudo.


Fluxo completo de compilação

Editor

JCL

JES2

Initiator

Compilador COBOL

Linkedit

Load Library

Execução

Relatórios

Arquivos

DB2

CICS

MQ


Erros clássicos

S806

S0C7

S322

SB37

IEC141I

JCL ERROR

DATASET NOT FOUND

NOT AUTHORIZED

MEMBER NOT FOUND

SPACE

DISP

CATALOG

Cada um explicado com linguagem simples.


Comparações divertidas

O Operador = Alfred

O RACF = Comissário Gordon

O JES2 = Central de Rádio de Gotham

O ISPF = Batcomputador

O SDSF = Batmonitor

O COBOL = Batmóvel

O JCL = Plano do Batman

O Compilador = Lucius Fox

O CICS = Bat-Sinal

O DB2 = Arquivo da Batcaverna

O MQ = Correio do Coringa


Easter Eggs

🦇 "Alguns dizem que o primeiro operador de mainframe já conhecia Batman antes mesmo da televisão colorida."

🦇 "Todo programador acredita que seu primeiro S0C7 foi culpa do compilador."

🦇 "Existe uma lenda segundo a qual nenhum desenvolvedor encontrou um JCL perfeito na primeira compilação."

🦇 "Assim como Robin apertava o botão errado, todo iniciante já digitou LOGOFF sem querer."

🦇 "O verdadeiro vilão nunca foi o Joker. Sempre foi o SPACE=(TRK,(1,1))."


Curiosidades históricas

  • nascimento do TSO
  • surgimento do ISPF
  • evolução do SDSF
  • JES2 × JES3
  • porque o 3270 não envia caractere por caractere
  • como nasceu o PF3
  • por que existem datasets
  • por que COBOL ainda usa colunas
  • por que o mainframe continua usando telas verdes
  • o que realmente acontece durante um IPL

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.

 

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

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

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

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