Translate

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

quinta-feira, 23 de abril de 2026

💣🔥 EzNoSQL no z/OS — O Golpe Silencioso: COMO O MAINFRAME APRENDEU JSON SEM PEDIR PERMISSÃO

 

Bellacosa Mainframe apresenta EzNoSQL no Z/OS

💣🔥 EzNoSQL no z/OS — O Golpe Silencioso: COMO O MAINFRAME APRENDEU JSON SEM PEDIR PERMISSÃO

Se você é COBOL júnior e acha que NoSQL é coisa de cloud, segura essa:
o mainframe não só entendeu… como absorveu o conceito sem quebrar uma linha de negócio.


🧬 Origem — de onde veio essa “mutação”?

Tudo começa com um problema real:

👉 Sistemas core em z/OS
👉 Dados rígidos em Db2, VSAM, IMS
👉 Mundo moderno falando JSON, REST, mobile, eventos

💥 Conflito inevitável.

A IBM já vinha preparando o terreno com:

  • Suporte a JSON no Db2
  • z/OS Connect expondo APIs
  • Integração com cloud

👉 O EzNoSQL for z/OS® surge como uma resposta pragmática:

💣 “E se a gente trouxer o modelo NoSQL pra dentro do mainframe ao invés de empurrar o mainframe pra fora?”


📅 História e lançamento

Diferente de produtos clássicos da IBM, o EzNoSQL não nasceu como um “big bang” tipo CICS ou Db2.

👉 Ele aparece por volta da década de 2010 (era pós-cloud), como parte da estratégia de:

  • Modernização de aplicações
  • APIs REST
  • Dados semi-estruturados

💡 Não é um produto mainstream amplamente divulgado como CICS ou Db2
👉 É mais nichado, usado em arquiteturas modernas híbridas


🧠 O que ele realmente é (explicação raiz)

Pensa assim, jovem COBOLista:

👉 VSAM = registro fixo
👉 Db2 = tabela estruturada
👉 EzNoSQL = documento flexível (tipo JSON)

Exemplo:

{
"conta": "123",
"cliente": "Bellacosa",
"apps": ["mobile", "web"],
"config": {
"notificacao": true
}
}

💣 Isso no mundo antigo exigiria:

  • várias tabelas
  • joins
  • redesign

👉 Aqui: 1 documento


⚙️ Como ele funciona na prática

Arquitetura típica:

App → API → z/OS Connect → COBOL → EzNoSQL

Integra com:

  • CICS
  • z/OS
  • Segurança via RACF

🚀 Vantagens (o lado poderoso)

🔥 1. Modernização sem reescrita

Você não precisa jogar COBOL fora.

👉 Você evolui.


⚡ 2. JSON nativo no mainframe

Perfeito para:

  • APIs REST
  • Mobile
  • Integrações modernas

🛡️ 3. Segurança absurda

Tudo herdado do mainframe:

  • RACF
  • auditoria
  • controle fino

🧩 4. Integração natural

Nada de ETL maluco ou sync externo.


⚠️ Desvantagens (a parte que ninguém te conta)

❌ 1. Não é cloud-native puro

Não compete diretamente com:

  • MongoDB
  • Cassandra

❌ 2. Escalabilidade diferente

Mainframe escala verticalmente
NoSQL moderno escala horizontalmente


❌ 3. Curva de entendimento

COBOL + JSON = choque cultural no começo 😅


🧪 Exemplo mental (modo Bellacosa)

🎯 Problema

Cliente muda preferências toda hora.

No Db2:

  • ALTER TABLE?
  • nova coluna?
  • impacto em batch?

💣 Dor.


🎯 Com EzNoSQL

{
"cliente": "123",
"preferencias": {
"tema": "dark",
"idioma": "pt-BR",
"notificacao": true
}
}

👉 Mudou? Só adiciona campo.

SEM ALTER TABLE.
SEM impacto global.


🧠 Curiosidades (nível raiz)

💡 EzNoSQL não substitui Db2
👉 Ele resolve outro tipo de problema

💡 Ele é mais comum em:

  • bancos
  • fintechs
  • modernização de legado

💡 Muitas vezes você usa sem perceber:
👉 “camada invisível” por trás de APIs


🥚 Easter Egg (essa é boa)

💣 O maior segredo:

Muita empresa diz:

👉 “Estamos usando microserviços modernos”

Mas por trás…

👉 ainda existe COBOL chamando algo tipo EzNoSQL no z/OS 😎


🧠 Insight profundo (pra você crescer rápido)

👉 O futuro NÃO é:

  • COBOL vs NoSQL
  • Mainframe vs Cloud

💣 O futuro é:

Mainframe + NoSQL + APIs + eventos


🧪 Analogia final (pra fixar de vez)

  • Db2 = planilha Excel organizada
  • VSAM = arquivo binário rápido
  • EzNoSQL = JSON flexível tipo API moderna

🚀 Conclusão

O EzNoSQL for z/OS® é uma peça estratégica:

👉 Ele permite que o mainframe:

  • fale JSON
  • exponha APIs
  • se conecte ao mundo moderno

💣 Sem perder:

  • performance
  • segurança
  • confiabilidade
  •  

quinta-feira, 29 de janeiro de 2026

💥 VSAM: O “Banco de Dados Gratuito” do z/OS — Muito Mais do Que Você Imagina

 

Bellacosa Mainframe uma visão para padawans do VSAM

💥 VSAM: O “Banco de Dados Gratuito” do z/OS — Muito Mais do Que Você Imagina

🧠 Explicação Enriquecida para Padawns

📌 O que é VSAM?

Tradução:
VSAM significa Virtual Storage Access Method. O termo “Access Method” surgiu lá nos anos 60 com o OS/360 e basicamente define como os dados são acessados (disco, fita, etc.).

Comentário Bellacosa:
👉 “Access Method” é o motor invisível do I/O no mainframe.
👉 VSAM é otimizado para disco — esqueça fita aqui (só backup/export).


📌 Tipos principais: ESDS vs KSDS

Tradução:

  • ESDS (Entry Sequenced Data Set)
    • Acesso via RBA (Relative Byte Address)
  • KSDS (Key Sequenced Data Set)
    • Acesso via chave ou RBA
    • Possui índice

Comentário prático:

TipoQuando usarMentalidade
ESDSLog, append-only, histórico“grava e nunca mexe”
KSDSCRUD clássico“mini banco de dados”

💡 Insight importante:
KSDS = VSAM mais próximo de banco relacional
ESDS = VSAM mais próximo de log estruturado


📌 Alternate Index (AIX)

Tradução:
Você pode criar índices alternativos (AIX) para acessar registros por outras chaves.

Comentário:
👉 Isso é o equivalente a índices secundários no DB2
👉 Mas aqui você controla tudo manualmente

💣 E aqui nasce a dor:

  • consistência
  • manutenção
  • performance

📌 Cluster, Componentes e Sphere

Tradução:

  • ESDS → Data component
  • KSDS → Data + Index component
  • Conjunto com AIX → chamado de Sphere

Comentário:
👉 “Sphere” é basicamente o ecossistema do dataset VSAM
👉 Em produção, isso vira uma mini arquitetura de dados


🚀 VSAM na Vida Real

Tradução:
VSAM continua sendo amplamente usado porque é:

  • rápido
  • escalável
  • já vem com z/OS
  • não exige banco adicional

Comentário forte:
💣 VSAM é o NoSQL original do mainframe
Antes de MongoDB existir, o z/OS já fazia isso há décadas


🔥 Caso real: Criando um Key/Value Store com VSAM

O autor implementa um banco estilo NoSQL key/value.


📌 Requisitos do sistema

Tradução + Expansão:

  • Fácil inserir/recuperar chave
  • Persistente (VSAM)
  • Rápido
  • Sem limite de tamanho
  • Permite agrupamento de chaves

Comentário:
👉 Isso é literalmente um Redis raiz no mainframe


🧪 Exemplo prático

Xsysvar 'MDLB URL'='https://MakingDevelopersLivesBetter.wordpress.com'
Xsysvar 'MDLB URL'

Saída:

https://MakingDevelopersLivesBetter.wordpress.com

💡 Tradução mental:
👉 SET / GET de um banco NoSQL
👉 Só que rodando em USS + VSAM


📦 Agrupamento de dados

Xsysvar -PZOS -C'z/OS CSI' CSI=MVS.GLOBAL.CSI
Xsysvar -l CSI

Saída:

ZOS CSI MVS.GLOBAL.CSI z/OS CSI

Comentário:
👉 Aqui entra conceito de namespace / grouping
👉 Muito parecido com:

  • tags
  • collections
  • schemas

🧠 Design inteligente do VSAM

📌 Problema: chave não pode ser longa

VSAM exige:

  • chave fixa
  • tamanho definido

💡 Solução genial

O autor divide a chave em:

ParteTipo
fixaaté 15 bytes
variávelaté 32K

Comentário avançado:
👉 Isso resolve:

  • limitação do VSAM
  • performance de indexação
  • flexibilidade

💣 Isso é arquitetura de baixo nível de respeito.


🧬 Layout do registro VSAM

Estrutura:

CampoFunção
Iflag ativo/inativo
Pproduct-id
Kchave
Vvalor
offsetsponteiros
Tárea variável
F-Ifiltros

🔥 Insight poderoso

👉 VSAM aqui está sendo usado como:

  • banco
  • indexador
  • storage engine

👉 Tudo manual

💣 Isso é o que bancos modernos fazem internamente!


⚠️ Limitação crítica do ESDS

Problema:

  • não permite aumentar tamanho do registro

Solução usada:

  • marca registro antigo como inativo
  • cria novo registro

💥 Tradução prática

👉 Isso é um UPDATE = DELETE + INSERT

Exatamente como:

  • Kafka log
  • bancos append-only

🧑‍💻 Acesso via C no z/OS

Funções usadas:

  • fopen()
  • fread()
  • fwrite()
  • flocate()
  • fupdate()

📌 Exemplo lógico

flocate(file, key);
fread(...);
fupdate(...);

💡 Comentário

👉 Isso é praticamente uma API de banco
👉 Só que nível kernel/mainframe


🔍 Função mais importante: vsamxlocate

O que faz:

  • busca chave
  • aplica filtros
  • percorre registros

💥 Tradução moderna

👉 Isso é um:

  • SELECT com WHERE
    • scan manual

🚀 Criação do VSAM (automação)

Comando:

crtvsam cluster repro key

💡 Comentário

👉 Isso substitui:

  • JCL complexo
  • IDCAMS manual

👉 Usando Z Open Automation Utilities


🔥 Conclusão (estilo Bellacosa)

👉 VSAM não é “arquivo”
👉 VSAM é um engine de dados low-level

💣 Você pode construir:

  • banco NoSQL
  • cache distribuído
  • config store
  • sistema transacional

🧠 Sacadas de Ouro

  • VSAM = NoSQL antes do NoSQL
  • ESDS = log append-only
  • KSDS = índice + acesso direto
  • AIX = índices secundários
  • UPDATE = recriação de registro
  • Performance vem do design da chave

🚀 Expansão além do texto (o pulo do gato)

💣 Se você quiser levar isso pro próximo nível:

Você pode:

1. Criar um Redis-like no z/OS

  • VSAM + C + USS

2. Criar API REST

  • z/OS Connect
  • consumindo VSAM

3. Integrar com COBOL

READ VSAM-FILE
KEY IS WS-KEY

🔥 Pergunta provocativa pra você

👉 E se você substituísse config files, tabelas pequenas e até alguns DB2 por VSAM bem modelado?

💣 Você reduziria:

  • custo
  • latência
  • dependência

domingo, 26 de outubro de 2025

☕🔥💣 IMS DL/I É O VERDADEIRO NoSQL ORIGINAL?

 

Bellacosa Mainframe apresenta conceitos de DL/I em IMS

☕🔥💣 IMS DL/I É O VERDADEIRO NoSQL ORIGINAL?

O dinossauro do mainframe que já fazia navegação hierárquica décadas antes do Vale do Silício inventar o termo “NoSQL”

Existe uma ironia maravilhosa na história da computação.

Durante anos o mercado vendeu a ideia de que:

  • NoSQL era revolucionário

  • bancos hierárquicos eram ultrapassados

  • o futuro havia finalmente derrotado o legado

Então, em algum momento, muita gente percebeu uma coisa desconfortável:

O IMS já fazia várias dessas ideias nos anos 60.

Sim.

Décadas antes de MongoDB, Cassandra, DynamoDB ou Redis existirem…

o velho IMS já trabalhava com:

  • navegação hierárquica

  • acesso sem SQL

  • paths previsíveis

  • estruturas não relacionais

  • acesso ultrarrápido

  • escalabilidade absurda

E isso gera uma pergunta extremamente provocativa:

O IMS DL/I pode ser considerado um NoSQL?

A resposta curta é:

☕ Tecnicamente… SIM.

Mas com algumas nuances MUITO interessantes.


🌳 Antes do SQL Existia o Mundo Selvagem

Hoje quase todo desenvolvedor nasce dentro do universo SQL.

Tudo gira em torno de:

SELECT
INSERT
UPDATE
DELETE
JOIN

Mas antes da explosão dos bancos relacionais, o cenário era completamente diferente.

Existiam:

  • bancos hierárquicos

  • bancos em rede

  • ISAM

  • VSAM

  • estruturas proprietárias

E foi nesse ambiente que nasceu o IMS.

Em 1968.

Durante o projeto Apollo.

Ou seja:

o IMS surgiu ANTES do SQL dominar o planeta.


🚀 O Que Define um Banco NoSQL?

Essa é a chave da discussão.

NoSQL normalmente significa:

“Not Only SQL”

Ou seja:

bancos que NÃO dependem do modelo relacional tradicional.

Exemplos modernos:

  • MongoDB → documento

  • Cassandra → colunar distribuído

  • Redis → chave/valor

  • Neo4j → grafos

O ponto central é:

O modelo não-relacional.

E aqui o IMS entra com força brutal.


🌳 IMS NÃO é Relacional

O IMS trabalha com:

Estruturas hierárquicas

Exemplo:

CLIENTE
 └── CONTA
      └── CARTAO
           └── MOVIMENTO

Isso NÃO é uma tabela relacional.

Não existem JOINs naturais.

Não existe optimizer SQL clássico.

Não existe álgebra relacional.

O acesso ocorre via:

  • navegação

  • paths

  • ponteiros físicos

  • hierarquia

Exatamente como muitos NoSQL modernos.


⚡ DL/I — O Anti-SQL

Aqui está a maior diferença filosófica.

No SQL você diz:

“O que eu quero.”

O banco decide:

  • índice

  • plano

  • join

  • optimizer

No DL/I você diz:

“Como navegar.”

Exemplo clássico:

CALL 'CBLTDLI'
     USING 'GU  '
           PCB
           AREA
           SSA.

O programador controla explicitamente:

  • navegação

  • path

  • posição

  • contexto hierárquico

Isso é MUITO mais próximo de certos bancos NoSQL modernos do que muita gente imagina.


💾 O IMS Já Fazia “Document Thinking”

Observe a estrutura:

CLIENTE
 └── CONTA
      └── MOVIMENTO

Isso lembra MUITO:

  • documentos aninhados

  • árvores JSON

  • estruturas embedded

Exatamente o tipo de modelagem popularizada décadas depois por MongoDB.

A diferença?

O IMS fazia isso quando memória ainda era luxo.


🚀 Então o IMS Era um MongoDB dos Anos 60?

😄

Não exatamente.

Mas existe uma verdade desconfortável:

Muitos conceitos NoSQL modernos já existiam no IMS.

Especialmente:

  • hierarquia

  • navegação direta

  • ausência de JOIN

  • acesso por path

  • performance orientada ao modelo físico


⚔️ Onde o IMS Difere do NoSQL Moderno

Aqui entram diferenças importantes.


🌐 Distribuição

Muitos NoSQL modernos nasceram para:

  • cloud

  • clusters massivos

  • commodity servers

  • sharding horizontal

O IMS nasceu para:

Mainframe centralizado de missão crítica.


🧠 Consistência

Muitos NoSQL modernos sacrificam:

  • consistência forte

  • ACID completo

em troca de escalabilidade.

O IMS faz o contrário.

Ele foi criado para:

  • integridade brutal

  • transações críticas

  • confiabilidade absoluta

Ou seja:

O IMS é MUITO mais conservador.


🔥 O IMS é Quase “Pré-NoSQL”

Talvez a melhor definição seja:

O IMS é um ancestral direto do pensamento NoSQL.

Porque ele já trabalhava com:

✅ modelo não relacional
✅ paths previsíveis
✅ hierarquia
✅ performance orientada à estrutura
✅ ausência de JOIN pesado

Décadas antes do termo existir.


🌳 O Grande Segredo: O Modelo Físico

A maioria dos bancos modernos tenta esconder o armazenamento físico.

O IMS faz quase o oposto.

No IMS avançado:

  • HDAM

  • HIDAM

  • DEDB

  • randomizers

  • root anchor points

influenciam diretamente o comportamento do banco.

O programador IMS clássico precisava entender:

COMO O DADO EXISTE NO DISCO.

Isso é extremamente raro hoje.


⚡ Por Que o IMS Continua Tão Rápido?

Porque ele evita camadas gigantescas de abstração.

No SQL moderno:

consulta
 → optimizer
 → parser
 → planner
 → join engine
 → executor

No IMS:

path → ponteiro → segmento

Muito mais direto.

Muito mais previsível.

Muito mais brutal.


☕ Easter Egg Mainframe

Existe uma piada cruel no mundo IMS:

“MongoDB reinventou a árvore.
IMS já morava na floresta.”

😄

E honestamente?

Existe bastante verdade nisso.


🌳 IMS e JSON — O Paradoxo Moderno

Aqui a coisa fica quase cyberpunk.

Hoje muitos sistemas modernos fazem:

JSON → API REST → z/OS Connect → IMS DL/I

Ou seja:

Aplicações mobile modernas acabam alimentando um banco hierárquico criado antes da internet existir.

Isso é absurdamente fascinante.


🚀 O Que os Desenvolvedores Modernos Não Percebem

Muita gente olha o IMS e pensa:

“legado.”

Veteranos enxergam outra coisa:

Engenharia extrema.

Porque o IMS foi construído numa época onde:

  • CPU era escassa

  • disco era lento

  • memória era minúscula

Então a IBM precisou criar um sistema:

  • previsível

  • eficiente

  • econômico

  • extremamente otimizado

O resultado?

Uma arquitetura que continua competitiva em workloads específicos até hoje.


⚔️ O SQL Venceu… Mas Não Matou o IMS

O SQL venceu o mercado corporativo.

Isso é fato.

Mas ele NÃO substituiu totalmente o IMS.

Porque existem workloads onde:

  • previsibilidade

  • TPS

  • throughput

  • latência mínima

são mais importantes que flexibilidade.

Especialmente em:

  • bancos

  • telecom

  • ATM

  • autorização financeira

  • seguros


🌐 O Verdadeiro Paradoxo

O mercado moderno adora chamar IMS de “tecnologia antiga”.

Mas muitas arquiteturas modernas acabaram:

voltando para ideias que o IMS já utilizava.

Inclusive:

  • modelos não relacionais

  • acesso orientado a documento

  • estruturas hierárquicas

  • paths previsíveis

  • performance baseada no modelo físico

A história da computação é cheia dessas ironias.


💣 Então… IMS DL/I É NoSQL?

A resposta mais honesta seria:

SIM.

Mas um NoSQL ancestral.

Um NoSQL criado décadas antes do marketing inventar o termo.

O IMS não nasceu tentando ser moderno.

Ele nasceu tentando sobreviver às limitações brutais dos anos 60.

E talvez justamente por isso ele ainda exista.

Porque no final das contas:

modas tecnológicas mudam.

Mas sistemas que realmente entregam performance absurda em missão crítica raramente desaparecem.

E o velho DL/I continua navegando pela árvore como poucos sistemas modernos conseguem fazer.