☕ 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 data. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta data. Mostrar todas as mensagens

quarta-feira, 17 de dezembro de 2025

📌 O que é STACK em REXX?

 


📌 O que é STACK em REXX?

Em REXX, STACK é uma pilha (fila LIFO/FIFO) de linhas de texto usada para:

  • Passar dados entre programas

  • Simular entrada padrão (PULL)

  • Trocar informações com JCL, TSO e batch

  • Comunicação entre execs

👉 Pense na STACK como um buffer de entrada/saída em memória.



1️⃣ STACK ≠ variável

A STACK:

  • Não é uma variável

  • Não precisa ser declarada

  • É global ao exec

  • Armazena linhas de texto

Ela é usada automaticamente por:

  • PULL

  • PARSE PULL

  • Alguns comandos de host


2️⃣ Comandos principais da STACK

📤 PUSH

Coloca uma linha no topo da pilha (LIFO).

PUSH 'linha 1' PUSH 'linha 2'

Ordem de saída:

linha 2 linha 1

📥 QUEUE

Coloca uma linha no final da fila (FIFO).

QUEUE 'linha 1' QUEUE 'linha 2'

Ordem de saída:

linha 1 linha 2

📄 PULL

Lê a próxima linha da STACK.

PULL dado

Se a STACK estiver vazia:

  • Em TSO → lê do terminal

  • Em batch → lê de SYSTSIN

  • Em SYSREXX → comportamento depende do ambiente


3️⃣ Diferença clara: PUSH x QUEUE

ComandoTipoUso típico
PUSHPilha (LIFO)Processamento reverso
QUEUEFila (FIFO)Simular input sequencial
PULLLeituraConsome a STACK

4️⃣ Exemplo simples e didático

/* REXX */ QUEUE 'primeiro' QUEUE 'segundo' QUEUE 'terceiro' PULL a PULL b PULL c SAY a SAY b SAY c

Saída:

primeiro segundo terceiro

5️⃣ STACK em Batch (uso real)

Em batch, a STACK é fundamental.

Exemplo: simular entrada para um programa

QUEUE 'MATH1 10 20' QUEUE 'exit' ADDRESS TSO CALL 'PROGCOB'

O COBOL lê como se fosse input real.


6️⃣ STACK + EXECIO (padrão profissional)

'EXECIO * DISKR INPUT (STEM in.' DO i = 1 TO in.0 QUEUE in.i END DO WHILE QUEUED() > 0 PULL linha SAY linha END

7️⃣ Função QUEUED()

Retorna quantas linhas existem na STACK.

IF QUEUED() = 0 THEN SAY 'Stack vazia'

💡 Boa prática: sempre testar antes de PULL.


8️⃣ STACK como comunicação entre execs

QUEUE 'valor1' QUEUE 'valor2' CALL OUTROEXEC PULL resposta

O outro exec pode consumir e devolver dados pela STACK.


9️⃣ Erros comuns (produção)

❌ Usar PULL sem saber de onde vem a entrada
❌ Deixar lixo na STACK
❌ Misturar PUSH e QUEUE sem critério
❌ Assumir que STACK sempre tem dados

✔ Sempre limpar ou controlar a STACK


🔟 Regra de ouro

STACK em REXX é entrada padrão controlável.
Quem domina STACK domina automação batch.


🧠 Frase para memorizar

QUEUE escreve o roteiro,
PUSH muda a ordem,
PULL executa a cena.

 

quinta-feira, 14 de abril de 2022

Lógica de Programação no Mainframe : O Guia Definitivo para um Programador Padawan Entender Como Pensar em COBOL

 

Bellacosa Mainframe apresenta logica de programacao em mainframe


☕ Um Café no Bellacosa Mainframe

Lógica de Programação no Mainframe

O Guia Definitivo para um Programador Padawan Entender Como Pensar em COBOL Antes Mesmo de Escrever uma Linha de Código

"A diferença entre um programador júnior e um programador experiente raramente está na linguagem. Está na forma como ele pensa antes de começar a programar."


Introdução

Existe um mito que acompanha praticamente todo iniciante em Mainframe.

Muitos acreditam que aprender COBOL significa decorar comandos como MOVE, IF, PERFORM, READ, WRITE e COMPUTE.

Não.

Isso é parecido com decorar palavras de um idioma sem aprender a formar frases.

Programar não é escrever código.

Programar é resolver problemas.

O computador apenas executa a solução que você imaginou.

Quanto melhor for sua lógica, menor será seu código.

Quanto pior for sua lógica, maior será o desastre.

Curiosamente, essa afirmação vale ainda mais no mundo Mainframe.

Em um sistema bancário, um erro lógico pode movimentar milhões de reais para a conta errada.

Um erro de apenas um operador relacional pode impedir milhares de aposentadorias de serem pagas.

A máquina faz exatamente aquilo que você pediu.

Nunca aquilo que você queria.


Afinal, o que é lógica de programação?

Lógica é a capacidade de organizar pensamentos em uma sequência de passos capazes de resolver um problema.

Em outras palavras:

Entrada → Processamento → Saída

Todo programa do planeta funciona assim.

Sempre.

Sem exceções.

Imagine fazer café.

Entrada:

  • água

  • café

  • filtro

Processamento:

  • aquecer água

  • passar pelo pó

Saída:

  • café pronto

Um programa COBOL faz exatamente isso.

Entrada:

Arquivo de clientes

Processamento

Arquivo atualizado

Nada muda.

Apenas o problema é diferente.


O computador é extremamente inteligente...

...para fazer exatamente o que você mandar.

E extremamente burro para adivinhar.

Se você esquecer um caso específico...

Ele esquecerá também.


Exemplo

Você deseja aprovar clientes maiores de idade.

Errado:

SE IDADE > 18

O cliente com exatamente 18 anos será recusado.

O correto seria

IDADE >= 18

Esse pequeno detalhe pode causar milhares de erros.

A lógica mora justamente nesses detalhes.


O primeiro segredo dos grandes programadores

Eles passam muito mais tempo pensando do que digitando.

Um programador experiente pode gastar:

70%

pensando

20%

planejando

10%

escrevendo

Já o iniciante faz exatamente o contrário.


Antes do COBOL existe o algoritmo

Todo programa começa com uma receita.

Exemplo.

Problema:

Calcular média de um aluno.

Passos.

Receber nota 1

Receber nota 2

Somar

Dividir por 2

Mostrar resultado

Isso é um algoritmo.

COBOL vem depois.


Aprenda primeiro estas estruturas

Toda programação procedural é formada por apenas três estruturas.

Sim.

Somente três.

Todo software do mundo nasce delas.


1 — Sequência

Faça isto

Depois aquilo

Depois aquilo outro

Exemplo

Leia salário

Calcule imposto

Mostre salário líquido

Nada complicado.


2 — Seleção

Agora aparece a primeira decisão.

SE saldo > 0

então saque permitido

senão

saque negado

No COBOL isso aparece como

IF
ELSE
END-IF

A vida inteira você fará isso.


3 — Repetição

Enquanto existir trabalho...

Continue trabalhando.

PERFORM UNTIL

PERFORM VARYING

São os famosos loops.


Curiosidade

Os três pilares da programação estruturada foram formalizados por Edsger W. Dijkstra, Ole-Johan Dahl e C. A. R. Hoare na década de 1960. A ideia revolucionária era simples: qualquer programa poderia ser construído usando apenas sequência, seleção e repetição, reduzindo drasticamente o uso de GOTO e tornando o software mais confiável.


Como um programa COBOL pensa?

Imagine um funcionário de banco.

Ele chega.

Recebe documentos.

Confere informações.

Atualiza cadastro.

Emite comprovante.

Vai embora.

Um programa COBOL trabalha exatamente assim.


Entrada

READ
ACCEPT
LINKAGE

Processamento

MOVE

ADD

SUBTRACT

MULTIPLY

DIVIDE

COMPUTE

STRING

UNSTRING

Saída

DISPLAY

WRITE

REWRITE

RETURN

SEND

O cérebro do programa

A PROCEDURE DIVISION.

Ela é composta por:

Parágrafos

Sections

Sentenças

Comandos

Cada um possui sua responsabilidade.


Parágrafos

Pense em capítulos de um livro.

CALCULAR-JUROS.

VALIDAR-DADOS.

ATUALIZAR-SALDO.

Cada um resolve uma única tarefa.

Essa organização melhora leitura, manutenção e testes.


Sections

São grupos de parágrafos relacionados.

Muito usadas em programas legados e ainda presentes em diversos ambientes corporativos.

VALIDACAO SECTION

PROCESSAMENTO SECTION

FINALIZACAO SECTION

Hoje, muitos times preferem programas menores e menos dependentes de SECTION, mas você encontrará ambos os estilos no mercado.


PERFORM é seu melhor amigo

Nunca copie código.

Faça um parágrafo.

Execute quando necessário.

PERFORM VALIDAR-CLIENTE

Muito melhor que repetir cinquenta linhas.


Variáveis

Uma variável representa um espaço reservado para armazenar informações.

Exemplo

Nome

Saldo

CPF

Data

Valor

Cada variável deve representar apenas uma ideia.

Não misture responsabilidades.


Um bom nome vale ouro

Ruim

A

X

TEMP

VAR1

Bom

WS-CLIENTE-SALDO

WS-VALOR-TOTAL

WS-DATA-PAGAMENTO

Você agradecerá daqui a dez anos.

E quem der manutenção também.


Expressões

Expressões representam cálculos.

A + B

SALDO - SAQUE

JUROS * TAXA

VALOR / PARCELAS

No COBOL moderno, COMPUTE simplifica expressões complexas, tornando o código mais legível.


Expressões booleanas

São perguntas.

IDADE >= 18

SALDO > 0

CPF = CPF-INFORMADO

Resultado?

VERDADEIRO

ou

FALSO

Toda programação gira em torno dessas respostas.


Operadores importantes

Igual

Maior

Menor

Maior ou igual

Menor ou igual

Diferente

AND

OR

NOT

Eles parecem simples.

Mas definem todo o comportamento do programa.


Fluxo de execução

Imagine uma estrada.

O programa começa.

Segue em frente.

Em alguns momentos:

vira

repete

retorna

encerra

Esse caminho é chamado fluxo.

Um fluxo claro é um programa fácil de manter.


O perigo do GO TO

Nos anos 70 era comum.

Hoje deve ser evitado.

Por quê?

Porque destrói o fluxo natural.

Cria o famoso:

"espaguete"

Linhas indo para todos os lados.

Difícil testar.

Difícil entender.

Difícil manter.

Por isso:

PERFORM

END-IF

EVALUATE

substituem praticamente todos os antigos GO TO.


EVALUATE

É o "switch" do COBOL.

Muito mais elegante que dezenas de IF aninhados.

Exemplo conceitual:

Cliente Ouro

↓

desconto

Cliente Prata

↓

desconto menor

Cliente Bronze

↓

sem desconto

Código mais limpo.

Mais fácil de ler.


Loops

No Mainframe você processará arquivos enormes.

Milhares.

Milhões.

Bilhões de registros.

Você não faz:

READ

READ

READ

READ

Você faz

PERFORM UNTIL EOF

Até chegar ao fim do arquivo.


EOF

Uma das primeiras variáveis que todo programador COBOL aprende.

WS-FIM-ARQUIVO

88 EOF VALUE "S"

Quando ela muda...

O loop termina.

Quase todo processamento batch funciona assim.


Subprogramas

Grandes bancos dividem responsabilidades.

Programa principal

Chama

Subprograma

Retorna resultado

Assim nasce software reutilizável.

Em COBOL isso ocorre com CALL.


O conceito de responsabilidade única

Cada parágrafo.

Cada rotina.

Cada subprograma.

Deve fazer apenas uma coisa.

Muito bem feita.

Esse conceito, hoje conhecido como Single Responsibility Principle, já aparecia naturalmente em muitos sistemas COBOL décadas antes de se popularizar na orientação a objetos.


Como pensar antes de programar

Faça estas perguntas.

Qual é o problema?

Quais dados entram?

Quais dados saem?

Quais regras existem?

Existem exceções?

O que acontece se faltar informação?

O arquivo pode estar vazio?

Pode existir duplicidade?

O valor pode ser negativo?

Quanto mais perguntas...

Menos bugs.


A diferença entre programar e desenvolver

Programar é escrever código.

Desenvolver é resolver problemas.

Um excelente desenvolvedor pode escrever poucas linhas.

Mas resolver um problema enorme.


O Mainframe muda sua forma de pensar

Aqui você aprende que:

dados são patrimônio;

performance importa;

I/O custa caro;

cada acesso a disco deve ser pensado;

processar um milhão de registros é rotina;

estabilidade vale mais que criatividade.

Essa mentalidade acompanha você por toda a carreira, mesmo trabalhando depois com Java, Python, Go ou JavaScript.


A disciplina do COBOL

COBOL obriga você a ser organizado.

Divisões bem definidas.

Dados separados da lógica.

Nomes claros.

Fluxo explícito.

Isso forma excelentes engenheiros de software.

Não por acaso, muitos arquitetos de grandes bancos começaram suas carreiras escrevendo COBOL.


Os erros mais comuns dos iniciantes

  • Programar antes de entender o problema.

  • Criar variáveis com nomes sem significado.

  • Misturar validação, cálculo e gravação na mesma rotina.

  • Usar GO TO sem necessidade.

  • Ignorar casos de erro e exceções.

  • Esquecer o tratamento de fim de arquivo.

  • Repetir código em vez de criar parágrafos reutilizáveis.

  • Não documentar regras de negócio complexas.

  • Alterar programas sem compreender seu fluxo completo.

  • Testar apenas o "caminho feliz", esquecendo entradas inválidas e situações de borda.


Trilha de estudos para um Padawan Mainframe

Uma sequência eficiente de aprendizado é:

  1. Lógica de programação.

  2. Algoritmos e fluxogramas.

  3. Tipos de dados e variáveis.

  4. Operadores e expressões.

  5. Estruturas de decisão (IF e EVALUATE).

  6. Estruturas de repetição (PERFORM, UNTIL e VARYING).

  7. Modularização com parágrafos, SECTION e subprogramas.

  8. Arquivos sequenciais e VSAM.

  9. JCL e execução batch.

  10. CICS, Db2, APIs e integração com o mundo moderno.


Easter Egg ☕

Existe uma velha brincadeira entre programadores veteranos.

Perguntaram a um desenvolvedor COBOL:

— Quantas linguagens você conhece?

Ele respondeu:

— Muitas.

— Então por que continua usando COBOL?

O veterano sorriu:

— Porque o banco prefere que o dinheiro continue chegando na conta certa.

A piada resume uma grande verdade: linguagens vêm e vão, mas a lógica permanece. Quem domina lógica aprende qualquer linguagem com muito mais facilidade.


Curiosidade histórica

Grace Hopper, uma das pioneiras da computação e uma das maiores influências para o COBOL, costumava dizer:

"A frase mais perigosa da linguagem é: 'Sempre fizemos assim'."

Embora COBOL seja uma linguagem com mais de seis décadas, ela continua evoluindo. Hoje suporta recursos modernos como JSON, XML, UTF-8, integração com APIs REST, chamadas a serviços, tratamento avançado de dados e otimizações para arquiteturas IBM Z. O que permanece imutável não é a sintaxe, mas a lógica por trás da solução.


Conclusão

Todo programador COBOL experiente conhece centenas de comandos.

Mas isso nunca foi o diferencial.

O diferencial sempre foi saber pensar.

A lógica de programação é a verdadeira linguagem universal da computação. Ela atravessa décadas, plataformas e paradigmas. O profissional que domina sequência, seleção, repetição, modularização, fluxo de execução e organização do pensamento será capaz de trabalhar não apenas com COBOL, mas também com Java, Python, C#, JavaScript, Go ou qualquer tecnologia que surgir no futuro.

No Mainframe, essa disciplina ganha um valor ainda maior. Cada programa processa informações críticas para bancos, seguradoras, hospitais, governos e empresas que movimentam bilhões de transações diariamente. Não há espaço para improvisação: clareza, simplicidade e previsibilidade são virtudes.

Lembre-se sempre desta máxima do Bellacosa Mainframe:

"O computador não premia quem escreve mais código. Ele recompensa quem pensa melhor. Antes de aprender COBOL, aprenda a organizar suas ideias. Depois disso, a linguagem será apenas uma ferramenta nas mãos de um verdadeiro engenheiro de software."

quarta-feira, 13 de março de 2019

O Relógio Invisível do CICS : Quando você Descobriu que Milhões de Transações Dependiam de um Tempo que Ninguém Conseguia Enxergar

 

Bellacosa Mainframe e o relogio invisivel do cics

☕ Um Café no Bellacosa Mainframe

O Relógio Invisível do CICS

Quando um Jovem Programador COBOL Descobriu que Milhões de Transações Dependiam de um Tempo que Ninguém Conseguia Enxergar

"Toda investigação começa com uma pergunta. No mundo do CICS, ela quase sempre é a mesma: exatamente quando isso aconteceu?"

O velho relógio da parede marcava 02h17 da madrugada.

No CPD, apenas o zumbido constante dos refrigeradores quebrava o silêncio. As luzes fluorescentes lançavam sombras longas sobre os armários metálicos, enquanto dezenas de fitas magnéticas repousavam como livros esquecidos em uma biblioteca de segredos.

Era a primeira semana de trabalho de Eduardo, um jovem programador COBOL recém-chegado ao banco.

Seu primeiro incidente parecia simples.

Um cliente afirmava que uma transferência de R$ 28.750,00 havia desaparecido.

O dinheiro saiu da conta.

Nunca chegou ao destino.

Ou pelo menos era isso que todos acreditavam.

O analista mais experiente do departamento, um senhor de cabelos grisalhos chamado apenas de Alberto, aproximou-se calmamente.

Sem olhar para o código perguntou:

— Você já perguntou ao CICS que horas eram?

Eduardo estranhou.

— Mas eu sei a hora...

Alberto sorriu.

— Não...

— Você sabe a hora que o relógio mostra.

— Eu quero saber a hora que o CICS acredita que era.

Naquele instante começava uma das maiores lições da carreira daquele jovem programador.

E também a nossa.


O Mistério do Tempo Invisível

Todo iniciante acredita que obter a data é algo extremamente simples.

Em Java existe:

LocalDateTime.now()

No Python:

datetime.now()

No C#:

DateTime.Now

Então por que o CICS inventou dois comandos?

  • ASKTIME

  • FORMATTIME

Por que não retornar simplesmente:

29/07/2026

10:45:22

A resposta está escondida dentro da própria arquitetura do CICS.

E ela é muito mais elegante do que parece.


O Tempo Não Existe

Parece estranho.

Mas, para um computador, datas não existem.

Nem horas.

Nem calendários.

Nem domingos.

Nem julho.

Muito menos sexta-feira.

Tudo isso é invenção humana.

O computador entende apenas números.

É exatamente por isso que o CICS criou um idioma próprio.

Esse idioma chama-se:

ABSTIME


ABSTIME: O Relógio Secreto do Mainframe

ABSTIME significa:

Absolute Time

Não é uma data.

Não é uma hora.

Não é um calendário.

É simplesmente um número gigantesco que representa um instante exato da existência do sistema.

Imagine uma régua infinita.

--------------------------------------------------------------->

Cada ponto representa um momento.

O ABSTIME é exatamente um desses pontos.

Ele não diz:

Quinta-feira.

Ele diz:

O instante número XXXXXXX desde a referência temporal usada pelo CICS.

É uma forma extremamente eficiente de representar o tempo.


Por que isso é genial?

Imagine duas operações bancárias.

Primeira:

10:45:10

Segunda:

10:45:15

Quanto tempo passou?

Nós fazemos mentalmente.

Cinco segundos.

Mas o computador precisaria interpretar:

  • dia

  • mês

  • ano

  • hora

  • minuto

  • segundo

Depois calcular.

Com ABSTIME?

Basta fazer:

Fim

-

Início

Pronto.

É matemática pura.

Nenhum calendário envolvido.


ASKTIME — Perguntando ao Universo

ASKTIME é um dos comandos mais simples do CICS.

E justamente por isso muitos subestimam sua importância.

EXEC CICS
     ASKTIME
     ABSTIME(WS-ABS-TIME)
END-EXEC.

Parece pequeno.

Mas ele acabou de conversar diretamente com o relógio do z/OS.

Imagine um funcionário indo até a sala onde fica o relógio atômico do banco.

Ele pergunta:

— Qual é o instante atual?

O relógio responde.

Mas responde em um idioma interno.

Não em português.

Nem inglês.

Responde em ABSTIME.


FORMATTIME — O Tradutor

Agora entra o segundo personagem.

FORMATTIME.

Ele olha para aquele número enorme e diz:

— Ah...

Já entendi.

Isso corresponde a:

29/07/2026

10:45:22

Ou então:

FRIDAY

Ou:

JULY

Ou:

2026

Tudo depende do formato solicitado.

Ele não cria informação.

Apenas traduz.


Uma Analogia Bellacosa

Imagine uma antiga máquina Enigma da Segunda Guerra Mundial.

O operador recebe:

YTRXKMQ

Para qualquer pessoa aquilo parece lixo.

Mas basta colocar na máquina correta.

Resultado:

ATAQUE AO AMANHECER

ABSTIME é a mensagem criptografada.

FORMATTIME é a máquina que decifra.


O Fluxo Completo

O caminho do tempo dentro do CICS é extremamente elegante.

Relógio do Hardware

↓

z/OS

↓

CICS

↓

ASKTIME

↓

ABSTIME

↓

FORMATTIME

↓

29/07/2026

10:45:22

Observe que o relógio nunca entrega diretamente uma data legível.

Existe uma camada de abstração.

Isso torna todo o sistema mais eficiente.


O Erro dos Programadores Iniciantes

É muito comum encontrar algo assim:

ASKTIME

FORMATTIME

...

ASKTIME

FORMATTIME

...

ASKTIME

FORMATTIME

Tudo dentro da mesma transação.

Isso é desperdício.

O relógio praticamente não mudou.

O correto geralmente é:

ASKTIME

↓

Guardar ABSTIME

↓

Reutilizar

É uma pequena otimização.

Mas imagine milhões de transações por dia.

Cada microssegundo economizado vira horas de processamento ao longo do ano.

É exatamente assim que os grandes sistemas sobrevivem durante décadas.


Um Caso Real de Auditoria

Imagine um PIX.

Às 14h15m22s.

O cliente afirma:

Nunca fiz essa transferência.

O banco consulta o log.

Encontra:

Data

Hora

Terminal

IP

Operador

Transação

Programa

Usuário RACF

Tudo isso nasceu de um único comando.

ASKTIME

Sem ele...

Toda a investigação estaria comprometida.


A Ciência do Tempo

Existe outro detalhe interessante.

Datas são péssimas para cálculos.

Imagine descobrir quanto tempo um programa levou para executar.

Com datas formatadas:

10:45:22

↓

10:45:24

É preciso interpretar texto.

Com ABSTIME:

Final

-

Inicial

=

2 segundos

Muito mais simples.

Muito mais rápido.


Curiosidade Histórica

Nos primeiros sistemas comerciais, muitos programas armazenavam datas apenas com dois dígitos para o ano.

Foi daí que nasceu o famoso Bug do Milênio (Y2K).

Quando chegou o ano 2000, vários sistemas interpretaram "00" como 1900.

O CICS, com sua abordagem baseada em ABSTIME e formatação controlada, ajudou a reduzir vários desses problemas em aplicações bem projetadas.

Essa história é um lembrete de que o tratamento correto do tempo nunca foi um detalhe trivial.


O Poder do DATESEP

Pouca gente presta atenção nisso.

DATESEP('/')

Resultado:

29/07/2026

DATESEP('-')

Resultado:

29-07-2026

DATESEP('.')

Resultado:

29.07.2026

Sem separador:

29072026

Extremamente útil para integrações.

Principalmente arquivos batch.


O Dia da Semana

FORMATTIME também sabe dizer:

MONDAY

TUESDAY

FRIDAY

Imagine um relatório.

Você quer saber:

Quantas transações aconteceram aos domingos?

Não precisa calcular.

FORMATTIME entrega.


O Nome do Mês

Também pode retornar:

JANUARY

FEBRUARY

MARCH

Parece detalhe.

Mas relatórios gerenciais adoram isso.

Imagine entregar ao diretor:

07

Agora compare com:

JULY

Muito mais amigável.


A Grande Diferença Entre Registrar e Medir

Um erro conceitual comum é acreditar que ASKTIME existe apenas para colocar data em relatórios.

Na verdade existem dois grandes usos.

Primeiro:

Registrar eventos.

Segundo:

Medir tempo.

Imagine:

ASKTIME

↓

Processamento

↓

ASKTIME

Agora basta comparar os dois ABSTIMEs.

Você descobre quanto tempo a rotina levou.

É exatamente assim que muitas medições de desempenho são realizadas em aplicações CICS.


Performance e Escalabilidade

Grandes bancos executam dezenas de milhares de transações por segundo.

Pequenas decisões fazem enorme diferença.

Capturar um único ABSTIME no início da Unidade de Trabalho e reutilizá-lo evita chamadas repetidas ao relógio do sistema, reduz overhead e mantém todos os registros daquela transação com a mesma referência temporal.

Esse cuidado também facilita auditorias, pois cada etapa compartilha o mesmo instante de origem quando isso faz sentido para o negócio.


Curiosidade

Muitos programadores COBOL passam anos utilizando ASKTIME sem nunca descobrir que o verdadeiro protagonista é o ABSTIME.

O comando parece apenas pegar a hora.

Na realidade ele captura um timestamp extremamente preciso utilizado internamente pelo CICS para cálculos temporais.

FORMATTIME é apenas o intérprete.


Dica de Ouro

Quando estiver projetando uma aplicação CICS, faça sempre estas perguntas:

  • Vou precisar apenas exibir a data?

  • Vou calcular intervalos entre eventos?

  • O mesmo horário deve representar toda a transação?

  • Existe um padrão corporativo para datas?

  • Os logs precisam ser comparados com Db2, VSAM, MQ ou outros sistemas?

Essas respostas influenciam diretamente a forma como você utilizará ASKTIME e FORMATTIME.


O Easter Egg do Bellacosa Mainframe 🕵️

Existe um velho comentário entre programadores veteranos:

"Quando um problema parece impossível de reproduzir, pergunte primeiro ao relógio."

Não é superstição.

Muitos incidentes em produção acabam sendo explicados apenas quando alguém reconstrói a sequência exata dos acontecimentos usando os timestamps registrados pela aplicação.

Em inúmeros casos, o "culpado" não era o programa COBOL, mas uma condição de corrida, um bloqueio temporário, uma transação concorrente ou uma diferença de poucos milissegundos entre operações críticas.

O relógio não mente.

Ele apenas registra.

Quem interpreta a história são os engenheiros.


Arquivo Confidencial nº 32 — O Caso do Relógio Invisível

Quando Eduardo finalmente terminou sua investigação, descobriu algo inesperado.

A transferência nunca desaparecera.

Dois programas distintos registraram o mesmo evento utilizando horários capturados em momentos diferentes. Um deles consultou o relógio logo no início da transação; o outro, segundos depois, após uma espera por bloqueio de recurso. Os logs pareciam contraditórios, mas o dinheiro havia seguido exatamente o fluxo esperado.

Na manhã seguinte, Alberto fechou o relatório, tomou um gole de café e disse:

— Está vendo por que nunca perguntamos apenas "que horas são"?

— Perguntamos "qual foi o instante registrado pelo CICS".

Eduardo sorriu.

Naquela madrugada ele deixou de ser apenas um programador COBOL.

Começava a pensar como um investigador de sistemas.

E desde então, sempre que escrevia um novo programa, lembrava-se de uma regra silenciosa que parecia ecoar pelos corredores do CPD:

"Os usuários enxergam datas. Os programadores enxergam horas. Mas o CICS enxerga apenas instantes."

Talvez seja por isso que, em todo grande mainframe, o relógio mais importante nunca aparece na parede. Ele vive escondido, contando silenciosamente a história de bilhões de transações — um ABSTIME de cada vez.

domingo, 8 de julho de 2018

☕💣 OPERADOR, ANTES DE EXISTIR O COBOL EXISTIA A LÓGICA! — O SEGREDO QUE TRANSFORMA APRENDIZES EM MESTRES DO MAINFRAME

 

Bellacosa Mainframe e a logica de programação estruturada para mainframe

☕💣 OPERADOR, ANTES DE EXISTIR O COBOL EXISTIA A LÓGICA! — O SEGREDO QUE TRANSFORMA APRENDIZES EM MESTRES DO MAINFRAME

Por que tantos profissionais aprendem COBOL, mas poucos se tornam realmente programadores?

Existe uma crença muito comum entre iniciantes no universo Mainframe:

"Se eu decorar comandos COBOL, vou aprender a programar."

Mas a realidade é outra.

Um programador COBOL experiente sabe que a linguagem é apenas uma ferramenta.

O verdadeiro diferencial está na lógica.

Quando observamos um sistema bancário executando milhões de transações por dia, um processamento batch consolidando contas correntes ou um programa CICS consultando dados em tempo real, o que realmente está funcionando por trás das telas verdes não é COBOL.

É a lógica.

O COBOL apenas traduz essa lógica para o computador.

Por isso, antes de estudar comandos avançados, VSAM, DB2, MQ ou CICS, é fundamental compreender os pilares da programação.

E curiosamente esses mesmos pilares já existiam muito antes dos computadores modernos.


O que é um algoritmo no mundo Mainframe?

A definição clássica diz que algoritmo é uma sequência finita de passos para resolver um problema.

No Mainframe podemos enxergar um algoritmo como um JOB.

Observe:

Exemplo cotidiano

Preparar café.

  1. Colocar água.

  2. Adicionar pó.

  3. Aquecer.

  4. Coar.

  5. Servir.

Existe uma sequência.

Se invertermos os passos, o resultado não será o esperado.


Exemplo Mainframe

Processar folha de pagamento.

  1. Ler arquivo de funcionários.

  2. Ler tabela salarial.

  3. Calcular salário.

  4. Calcular impostos.

  5. Gerar relatório.

  6. Atualizar arquivo mestre.

Perceba:

Um programa COBOL nada mais é que uma sequência organizada de passos.

Isso é um algoritmo.


O algoritmo invisível que existe em todo JOB

Quando um operador submete um JCL:

//JOB001 JOB ...
//STEP01 EXEC PGM=LEFUNC
//STEP02 EXEC PGM=CALCSAL
//STEP03 EXEC PGM=RELATOR

O JCL é um algoritmo.

Ele determina:

  • O que executar.

  • Em qual ordem.

  • Quais dados utilizar.

  • Qual resultado produzir.

Sem lógica não existe processamento.


O conceito mais importante de toda programação

Todo programa responde a três perguntas:

O que entra?

Input.

O que acontece?

Processamento.

O que sai?

Output.


Exemplo COBOL

Imagine um programa que calcula a média de um aluno.

Entrada:

01 WS-NOTA1 PIC 9(3)V99.
01 WS-NOTA2 PIC 9(3)V99.

Processamento:

COMPUTE WS-MEDIA =
        (WS-NOTA1 + WS-NOTA2) / 2.

Saída:

DISPLAY "MEDIA = " WS-MEDIA.

Observe:

Entrada → Processamento → Saída

Esse modelo está presente em praticamente todos os sistemas Mainframe.


Tipos de dados: os tijolos da programação COBOL

Todo programa trabalha com dados.

No COBOL eles são definidos na DATA DIVISION.


Dados numéricos

Exemplos:

01 WS-IDADE PIC 999.
01 WS-SALARIO PIC 9(7)V99.

Utilizados para:

  • cálculos;

  • somatórios;

  • médias;

  • juros;

  • impostos.


Dados alfanuméricos

Exemplos:

01 WS-NOME PIC X(40).
01 WS-CPF  PIC X(11).

Utilizados para:

  • nomes;

  • documentos;

  • códigos;

  • mensagens.


Dados lógicos no COBOL

COBOL não possui BOOLEAN clássico como linguagens modernas.

Normalmente utilizamos:

88 CLIENTE-ATIVO VALUE 'S'.
88 CLIENTE-INATIVO VALUE 'N'.

Ou:

01 WS-STATUS PIC X.

   88 APROVADO VALUE 'A'.
   88 REPROVADO VALUE 'R'.

Esse recurso é extremamente utilizado em sistemas bancários.


Variáveis: os registradores da aplicação

Uma variável representa uma área de memória.

Exemplo:

01 WS-SALDO PIC S9(9)V99 COMP-3.

Durante a execução:

MOVE 1000 TO WS-SALDO.

Depois:

ADD 500 TO WS-SALDO.

Valor atual:

1500

A variável mudou.

Por isso ela recebe esse nome.


Constantes em COBOL

Valores fixos normalmente são definidos com VALUE.

01 WS-TAXA-JUROS PIC 9V999
   VALUE 0.125.

Ou:

01 WS-PI PIC 9V99999
   VALUE 3.14159.

O conceito é simples:

Uma constante não deve mudar.


MOVE: o comando mais utilizado do COBOL

Na apostila existe o conceito de atribuição.

No COBOL isso ocorre principalmente através do comando MOVE.

Exemplo:

MOVE 100 TO WS-SALDO.

Significa:

"Coloque o valor 100 dentro da variável."

Outro exemplo:

MOVE WS-NOME TO WS-NOME-CLIENTE.

Equivale à atribuição de uma variável para outra.


Entrada e saída de dados no Mainframe

Em linguagens acadêmicas encontramos:

Leia
Escreva

No COBOL encontramos:

READ
WRITE
DISPLAY
ACCEPT


Entrada de dados

Terminal:

ACCEPT WS-NOME.

Arquivo:

READ ARQ-CLIENTES

Saída de dados

Tela:

DISPLAY WS-NOME.

Arquivo:

WRITE REG-SAIDA.

Relatório:

WRITE LINHA-RELATORIO.

Operadores matemáticos no COBOL

O COBOL utiliza verbos muito próximos da linguagem humana.


Soma

ADD A TO B.

Subtração

SUBTRACT A FROM B.

Multiplicação

MULTIPLY A BY B.

Divisão

DIVIDE A INTO B.

Fórmulas complexas

COMPUTE WS-MEDIA =
       (WS-NOTA1 + WS-NOTA2) / 2.

O COMPUTE é um dos comandos mais poderosos da linguagem.


Operadores relacionais

São utilizados para comparar valores.


Igual

IF WS-IDADE = 18

Maior

IF WS-SALDO > 1000

Menor

IF WS-SALDO < 0

Diferente

IF WS-STATUS NOT = 'A'

O poder do IF

Todo sistema bancário depende de decisões.

A decisão é implementada através do IF.


Exemplo

IF WS-SALDO > 0
    DISPLAY "CONTA POSITIVA"
END-IF.

Exemplo bancário

IF WS-LIMITE > WS-VALOR-SAQUE
    PERFORM EFETUA-SAQUE
ELSE
    PERFORM NEGA-SAQUE
END-IF.

Observe:

O programa está tomando decisões.

Isso é lógica.


EVALUATE: o SWITCH/CASE do COBOL

Em outras linguagens existe SWITCH.

No COBOL moderno utilizamos:

EVALUATE WS-STATUS
   WHEN 'A'
      DISPLAY 'ATIVO'
   WHEN 'I'
      DISPLAY 'INATIVO'
   WHEN OTHER
      DISPLAY 'INVALIDO'
END-EVALUATE.

Muito comum em sistemas corporativos.


Estruturas de repetição no COBOL

Um dos conceitos mais importantes da programação.

Imagine um arquivo com 50 milhões de registros.

Como processar tudo?

Com laços de repetição.


PERFORM UNTIL

PERFORM UNTIL EOF = 'S'

   READ ARQ-CLIENTES
      AT END
         MOVE 'S' TO EOF
   END-READ

END-PERFORM.

Esse é provavelmente um dos padrões mais encontrados no Mainframe.


O algoritmo clássico de processamento batch

Observe a lógica utilizada em milhares de programas COBOL:

ABRIR ARQUIVOS

LER PRIMEIRO REGISTRO

ENQUANTO NÃO FOR FIM DO ARQUIVO

   PROCESSAR

   LER PRÓXIMO REGISTRO

FIM-ENQUANTO

FECHAR ARQUIVOS

Transformado para COBOL:

OPEN INPUT ARQ-CLIENTES

PERFORM UNTIL EOF = 'S'

   READ ARQ-CLIENTES
      AT END
         MOVE 'S' TO EOF
      NOT AT END
         PERFORM PROCESSA-REGISTRO
   END-READ

END-PERFORM

CLOSE ARQ-CLIENTES.

Esse padrão existe há décadas.

E continua executando boa parte da economia mundial.


A lógica por trás de CICS

Muitos acreditam que CICS é algo completamente diferente.

Mas a lógica é a mesma.

Entrada:

EXEC CICS RECEIVE

Processamento:

IF
EVALUATE
COMPUTE

Saída:

EXEC CICS SEND

Novamente:

Entrada → Processamento → Saída.


O segredo dos grandes programadores COBOL

Os melhores profissionais não decoram comandos.

Eles aprendem a pensar.

Quando recebem uma demanda, primeiro desenham a lógica.

Depois escrevem o código.

Por isso um profissional experiente consegue aprender:

  • COBOL

  • PL/I

  • Natural

  • Java

  • Python

  • C#

Porque a lógica permanece.

A linguagem muda.

O raciocínio não.


Conclusão

Todo sistema Mainframe que processa cartões, PIX, contas correntes, seguros, previdência, telecomunicações ou governo possui a mesma fundação:

Algoritmos.

Variáveis.

Decisões.

Repetições.

Processamento de dados.

O COBOL não é apenas uma linguagem.

Ele é a materialização de uma lógica extremamente bem estruturada, criada para representar regras de negócio de forma clara e confiável.

Quem domina apenas comandos escreve programas.

Quem domina lógica constrói sistemas que sobrevivem décadas.

E talvez esse seja o maior segredo do Mainframe:

Os computadores mudaram.

As telas mudaram.

As linguagens mudaram.

Mas a lógica continua exatamente a mesma desde os primeiros dias da computação.



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...