Autor: admin

[NÍVEL AVANÇADO] Exercícios Complexos de REXX
Domine IF, SELECT e Loops com problemas do mundo real

🔥 DESAFIO 1: Analisador de Logs de Job

rexx

/*
OBJETIVO: Analisar múltiplas linhas de log
SIMULAÇÃO: Você recebe um array com status de jobs
CADA LINHA: "JOBNAME;STARTTIME;ENDTIME;RC"

EXEMPLO:
jobs.1 = "JOB001;08:00;08:05;00"
jobs.2 = "JOB002;08:05;08:07;04"
jobs.3 = "JOB003;08:07;08:10;00"

TAREFAS:
1. Calcular tempo de cada job
2. Identificar jobs com RC ≠ 0
3. Calcular tempo total de processamento
4. Encontrar job mais longo

DICA: Use PARSE para separar por ";"
*/

🔥 DESAFIO 2: Sistema de Menu com Validação

rexx

/*
OBJETIVO: Criar sistema de menu profissional
REQUISITOS:
1. Loop infinito com opção de sair
2. Validação de entrada
3. Submenus
4. Histórico de operações
5. Limpeza de tela entre menus

ESTRUTURA:
MENU PRINCIPAL:
1. Processamento
2. Relatórios
3. Utilitários
4. Sair

SUBMENU Processamento:
1.1 Validar dados
1.2 Importar arquivos
1.3 Voltar

DICA: Use DO FOREVER, SELECT aninhados
*/

🔥 DESAFIO 3: Gerador de Scripts JCL

rexx

/*
OBJETIVO: Gerar JCL dinamicamente
ENTRADA: Parâmetros do job
SAÍDA: Script JCL pronto para usar

PARÂMETROS:
- Nome do job (1-8 chars)
- Programa a executar
- Dataset de entrada
- Dataset de saída
- Região de memória
- Classe

EXEMPLO DE SAÍDA:
//JOB001  JOB ,'DESC',CLASS=A
//STEP1   EXEC PGM=PROGRAM1
//INPUT   DD DSN=USER.DATA.IN
//OUTPUT  DD DSN=USER.DATA.OUT

DICA: Use loops para múltiplos steps
*/

💡 SOLUÇÃO do Desafio 1 (após tentativa):

rexx

/* SOLUCAO_LOGS.rex */
/* Array simulado de jobs */
jobs.1 = "JOB001;08:00;08:05;00"
jobs.2 = "JOB002;08:05;08:07;04"
jobs.3 = "JOB003;08:07;08:10;00"
total_jobs = 3

/* Variáveis de análise */
total_tempo = 0
jobs_com_erro = 0
job_mais_longo = ""
tempo_mais_longo = 0

SAY "=== ANÁLISE DE LOGS DE JOB ==="
SAY ""

DO i = 1 TO total_jobs
  /* Parse para separar campos */
  PARSE VAR jobs.i nome ";" inicio ";" fim ";" rc
  
  /* Calcular tempo (em minutos) */
  PARSE VAR inicio hh_in ":" mm_in
  PARSE VAR fim hh_fim ":" mm_fim
  
  inicio_min = (hh_in * 60) + mm_in
  fim_min = (hh_fim * 60) + mm_fim
  duracao = fim_min - inicio_min
  
  /* Acumular totais */
  total_tempo = total_tempo + duracao
  
  /* Verificar RC */
  IF rc <> "00" THEN DO
    jobs_com_erro = jobs_com_erro + 1
    SAY "ALERTA: Job" nome "falhou com RC =" rc
  END
  
  /* Verificar job mais longo */
  IF duracao > tempo_mais_longo THEN DO
    tempo_mais_longo = duracao
    job_mais_longo = nome
  END
  
  SAY "Job:" nome "- Duração:" duracao "minutos - RC:" rc
END

/* Relatório final */
SAY ""
SAY "=== RELATÓRIO FINAL ==="
SAY "Total de jobs:" total_jobs
SAY "Jobs com erro:" jobs_com_erro
SAY "Tempo total:" total_tempo "minutos"
SAY "Job mais longo:" job_mais_longo "(" tempo_mais_longo "min)"
SAY "Tempo médio:" (total_tempo / total_jobs) "minutos por job"

IF jobs_com_erro > 0 THEN
  SAY "ATENÇÃO: Existem jobs que precisam de análise!"
ELSE
  SAY "SUCESSO: Todos os jobs executaram corretamente!"

📚 RECURSOS ADICIONAIS:

• Playlist completa do curso: [link]

• Códigos-fonte: [link para repositório]

• Comunidade no Discord: [link]

• Cheat Sheet REXX: [download]

🔔 CHAMADA FINAL:
Inscreva-se no canal para não perder as próximas aulas avançadas sobre:

• Interação com TSO/ISPF

• Processamento de arquivos

• Funções personalizadas

• Debugging profissional

• Integração com COBOL e DB2

#REXX #Mainframe #zOS #Programação #Automação #TSO #ISPF #Exercícios #Lógica #Developer

 [DESAFIO] Exercícios REXX: Sua Hora de Brilhar!
Consolidando aulas 01-03 com problemas reais do mainframe

🎯 DESAFIO 1: Calculadora de IMC

rexx

/* 
OBJETIVO: Criar calculadora de IMC
ENTRADA: Peso (kg) e Altura (m)
SAÍDA: IMC e classificação

Classificação:
- Abaixo de 18.5: Abaixo do peso
- 18.5 a 24.9: Normal
- 25 a 29.9: Sobrepeso
- Acima de 30: Obesidade

DICA: Use SAY, PULL e IF/ELSE
*/

🎯 DESAFIO 2: Validador de Dataset Name

rexx

/*
OBJETIVO: Validar nomes de dataset
REGRAS:
1. Máximo 44 caracteres
2. Deve começar com letra
3. Partes separadas por ponto
4. Cada parte: 1-8 caracteres
5. Caracteres válidos: A-Z, 0-9, @#$ (apenas no primeiro caractere da parte)

EXEMPLOS VÁLIDOS:
- USER.DATA01
- PROJ#.TEST.COBOL

DICA: Use LENGTH, SUBSTR, DATATYPE
*/

🎯 DESAFIO 3: Formatador de Data Mainframe

rexx

/*
OBJETIVO: Converter data do mainframe
ENTRADA: "DDMMYYYY" (ex: "15032024")
SAÍDA: "15/MAR/2024"

MESES: 01=JAN, 02=FEV, ..., 12=DEZ

EXTRA: Validar se data é válida
- Dia: 01-31
- Mês: 01-12
- Ano: 1900-2100

DICA: Use SUBSTR para separar partes
*/

💡 SOLUÇÃO do Desafio 1 (após tentativa):

/* SOLUCAO_IMC.rex */
SAY '=== CALCULADORA IMC ==='
SAY 'Digite seu peso (kg):'
PULL peso
SAY 'Digite sua altura (m):'
PULL altura

imc = peso / (altura * altura)
SAY 'Seu IMC é:' FORMAT(imc, , 2)  /* 2 casas decimais */

SELECT
  WHEN imc < 18.5 THEN classificacao = 'Abaixo do peso'
  WHEN imc <= 24.9 THEN classificacao = 'Peso normal'
  WHEN imc <= 29.9 THEN classificacao = 'Sobrepeso'
  OTHERWISE classificacao = 'Obesidade'
END

SAY 'Classificação:' classificacao
SAY '========================'

CTA: 💬 Poste sua solução nos comentários e ajude outros alunos!

Manipulação de Strings: O Superpoder do REXX!
Funções nativas que transformam dados brutos em informação valiosa

🔤 Funções de String ESSENCIAIS:

rexx

/* LENGTH - Tamanho da string */
nome = "Mainframe"
tamanho = LENGTH(nome)  /* = 9 */

/* SUBSTR - Extrai parte da string */
texto = "REXX é incrível"
parte = SUBSTR(texto, 6, 2)  /* = "é" */

/* INDEX - Encontra posição */
pos = INDEX("Hello World", "World")  /* = 7 */

/* WORDS e WORD - Trabalhando com palavras */
frase = "REXX no mainframe z/OS"
quantas = WORDS(frase)  /* = 4 palavras */
terceira = WORD(frase, 3)  /* = "mainframe" */

🛠️ Kit completo de funções:

rexx

/* CONVERSÕES */
num = "123"
valor = num + 1  /* REXX converte automaticamente! */

/* Maiúsculas/minúsculas */
grande = UPCASE("rexx")  /* = "REXX" */
pequena = LOWER("IBM")   /* = "ibm" */

/* Formatação */
centralizado = CENTER("Título", 20, "-")
/* = "-------Título-------" */

/* Busca e substituição */
novo = CHANGE("Olá Mundo", "Mundo", "Mainframe")
/* = "Olá Mainframe" */

💼 Exemplo REAL no mainframe:

rexx

/* ANALISA_JOB.rex - Analisa saída de job */
saida = "JOB1234 ENDED OK - 00:05:23 EXECUTION" 
/* Suponha que isso veio de um arquivo de log */

/* Extrai informações */
IF POS('ENDED OK', saida) > 0 THEN DO
  /* Encontra tempo de execução */
  pos_inicio = INDEX(saida, '00:')
  tempo = SUBSTR(saida, pos_inicio, 8)
  
  /* Extrai número do job */
  primeiro_espaco = INDEX(saida, ' ')
  job_num = SUBSTR(saida, 1, primeiro_espaco-1)
  
  SAY 'Job' job_num 'concluído com sucesso!'
  SAY 'Tempo de execução:' tempo
END ELSE DO
  SAY 'Job não concluído corretamente'
  SAY 'Status:' WORD(saida, 3)
END

📊 Processando múltiplas linhas:

rexx

/* Processa lista de datasets */
datasets = "USER.DATA.CLIENTES",
           "USER.DATA.VENDAS",
           "USER.DATA.PRODUTOS"

DO i = 1 TO WORDS(datasets)
  dsname = WORD(datasets, i)
  
  /* Extrai último componente */
  ultimo_ponto = LASTPOS('.', dsname)
  tipo = SUBSTR(dsname, ultimo_ponto + 1)
  
  SAY 'Dataset' i ':' tipo '->' dsname
END

🎁 BÔNUS: Funções úteis pouco conhecidas:

rexx

/* SPACE - Controla espaços entre palavras */
compacto = SPACE("REXX    no   mainframe", 1)

/* COPIES - Repete strings */
separador = COPIES('-', 30)  /* 30 traços */

/* DATATYPE - Verifica tipo */
SAY DATATYPE("123")   /* = NUM */
SAY DATATYPE("ABC")   /* = CHAR */
SAY DATATYPE(" ")     /* = BLANK */

CTA: 📚 Material completo com TODAS as funções nos comentários!

Loops REXX: A Arte da Repetição Inteligente
DO, WHILE, FOREVER – Automatize qualquer tarefa repetitiva

➿ Tipos de loops:

1. DO simples (contador):

rexx

/* Contar de 1 a 10 */
DO i = 1 TO 10
  SAY 'Iteração' i
END

2. DO WHILE (enquanto verdade):

rexx

/* Loop com condição no início */
contador = 1
DO WHILE contador <= 5
  SAY 'Executando...' contador
  contador = contador + 1
END

3. DO UNTIL (até que verdade):

rexx

/* Loop com condição no final */
contador = 0
DO UNTIL contador >= 3
  SAY 'Digite um valor (0 para sair):'
  PULL valor
  contador = contador + 1
END

4. DO FOREVER (infinito com saída controlada):

rexx

/* Menu principal de sistema */
DO FOREVER
  SAY '=== MENU PRINCIPAL ==='
  SAY '1. Processar'
  SAY '2. Relatório'
  SAY '3. Sair'
  PULL opcao
  
  IF opcao = 3 THEN LEAVE  /* Sai do loop */
  
  /* Processa opção */
  SELECT
    WHEN opcao = 1 THEN SAY 'Processando...'
    WHEN opcao = 2 THEN SAY 'Gerando relatório...'
    OTHERWISE SAY 'Opção inválida'
  END
END
SAY 'Programa encerrado.'

🔧 Exemplo prático – Processar arquivo:

rexx

/* Simulando leitura de arquivo */
linhas = 5  /* Suponha que temos 5 linhas */

SAY 'Processando' linhas 'linhas...'
DO i = 1 TO linhas
  SAY 'Processando linha' i
  /* Aqui viria código real de processamento */
  IF i = 3 THEN ITERATE  /* Pula a linha 3 */
  SAY 'Linha' i 'processada com sucesso.'
END
SAY 'Processamento completo!'

⚡ Dicas profissionais:

• Use LEAVE para sair antecipadamente de um loop

• Use ITERATE para pular para próxima iteração

• Evite loops infinitos acidentais

• Sempre teste condições de saída

CTA: 👉 Agora falta aprender a manipular textos como um expert!

IF, SELECT e o Poder das Decisões no REXX
Faça seus scripts “pensarem” e adaptarem-se a qualquer situação

🔄 IF/THEN/ELSE – Decisões simples:

/* Formato básico */
IF condição THEN
instrução
ELSE
outra_instrução

/* Exemplo prático */
SAY 'Qual sua idade?'
PULL idade

IF idade < 0 THEN
SAY 'Idade inválida!'
ELSE IF idade < 18 THEN
SAY 'Você é menor de idade'
ELSE
SAY 'Você é maior de idade'

🎯 SELECT/WHEN – Múltiplas condições:

/* Estrutura SELECT - perfeita para menus */
SAY 'Escolha uma opção:'
SAY '1. Relatório de clientes'
SAY '2. Backup diário'
SAY '3. Limpeza de logs'
PULL opcao

SELECT
WHEN opcao = 1 THEN DO
SAY 'Gerando relatório...'
/* código do relatório */
END
WHEN opcao = 2 THEN
SAY 'Iniciando backup...'
WHEN opcao = 3 THEN
SAY 'Limpando logs...'
OTHERWISE
SAY 'Opção inválida!'
END

💼 Exemplo real – Validação de dados:

/* VALIDA.rex - Validação de entrada */
SAY 'Digite o código do produto (3 letras):'
PULL codigo

SELECT
WHEN LENGTH(codigo) <> 3 THEN
SAY 'ERRO: Código deve ter 3 caracteres'
WHEN DATATYPE(codigo) <> 'CHAR' THEN
SAY 'ERRO: Use apenas letras'
WHEN codigo = 'ABC' THEN
SAY 'Produto: Componente A'
WHEN codigo = 'XYZ' THEN
SAY 'Produto: Componente B'
OTHERWISE
SAY 'Produto desconhecido'
END

CTA: 👉 Na próxima: Aprenda a repetir tarefas com loops poderosos!

Variáveis REXX: A Flexibilidade que Você Sempre Quis!
SAY, PULL e operadores – sua base para scripts interativos

🧮 VARIÁVEIS no REXX:

• Tipagem dinâmica: mesma variável pode ter número ou texto

• Declaração implícita: basta usar!

• Nomes: até 250 caracteres, case-sensitive

• Valores: strings (até 65.535 caracteres)

📊 OPERADORES:

/* Aritméticos: + - * / % // */ resultado = 10 + 5 * 2 /* = 20 */ /* Comparação: = > < >= <= <> */ IF valor > 100 THEN SAY 'Alto' /* Lógicos: & | \ (AND, OR, NOT) */ IF (idade >= 18) & (status = 'A') THEN...

🗣️ INTERAÇÃO com SAY e PULL:

/* SAY - Mostra na tela */ SAY 'Qual seu nome?' PULL nome /* Aguarda entrada */ SAY 'Olá,' nome '! Bem-vindo ao mainframe.' /* PULL múltiplas variáveis */ SAY 'Digite nome e idade:' PULL nome idade SAY nome 'tem' idade 'anos'

Exemplo prático – Calculadora simples:

/* CALC.rex - Calculadora interativa */
SAY '--- Calculadora REXX ---'
SAY 'Digite primeiro número:'
PULL num1
SAY 'Digite segundo número:'
PULL num2
SAY 'Soma:' num1 + num2
SAY 'Subtração:' num1 - num2
SAY 'Multiplicação:' num1 * num2
IF num2 <> 0 THEN SAY 'Divisão:' num1 / num2

CTA: 👉 Agora sim! Prontos para programas que tomam decisões?

Hello Mainframe! Seu Primeiro Programa REXX no z/OS
Do TSO à execução: veja onde e como rodar seus scripts REXX

🔧 ONDE rodar REXX:

• TSO/E (Time Sharing Option) – linha de comando

• ISPF Editor – criar e executar diretamente

• Batch (JCL) – para processamentos pesados

• Ferramentas como REXX Compiler e Debugger

📝 ESTRUTURA BÁSICA de um programa REXX:

• Comentários: /* */ (primeira linha especial)

• Case-insensitive: SAY = say = Say

• Não precisa declarar variáveis!

• Execução sequencial, linha a linha

🖥️ HANDS-ON: Hello World no Mainframe

/* MEUPRIM.rex - Primeiro programa REXX */
SAY '================================='
SAY ' HELLO MAINFRAME WORLD! '
SAY ' Programa executado em:' DATE()
SAY '================================='
EXIT 0

Passo a passo:

Acesse o TSO

Entre no ISPF (=3.4 para editor)

Digite o programa

Salve como MEUPRIM.REX

Execute com EX ‘MEUPRIM.REX’

CTA: 👉 Na próxima: Vamos aprender a fazer programas que interagem com você!

REXX no Mainframe: Sua Ponte para a Automação Inteligente!
Descubra por que esta linguagem amigável é um superpoder no mundo z/OS.

📌 O QUE é REXX?

• REXX (Restructured Extended Executor): linguagem de scripting poderosa e legível

• Criada pela IBM nos anos 1970, mas incrivelmente moderna

• Linguagem interpretada, perfeita para automação rápida

🎯 POR QUE REXX no Mainframe?

• Nativa do ambiente z/OS (vem “de fábrica”)

• Sintaxe simples e intuitiva – parecida com inglês do dia a dia

• Acesso direto a comandos do TSO, ISPF e até do sistema operacional

• Processamento de strings excepcionalmente poderoso

🚀 PRINCIPAIS USOS no z/OS:

• Automação de tarefas administrativas

• Processamento de arquivos (seqüenciais, PDS, VSAM)

• Geração de relatórios customizados

• Interface com outras linguagens (COBOL, PL/I)

• Desenvolvimento de CLISTs mais sofisticados

Exemplo motivador:

/* Exemplo simples - já dá para sentir a simplicidade */
SAY "Olá, Mainframe! Vamos automatizar tudo?"

CTA: 👉 Próxima aula: Vamos colocar a mão na massa e escrever nosso primeiro programa!

**COMPUTADORES QUÂNTICOS: A NOVA FRONTEIRA E O LEGADO VISIONÁRIO DE MICHIO KAKU**

Estamos no limiar de uma transição silenciosa, porém radical, na história da computação e da compreensão humana. Enquanto o mundo digital clássico, alicerçado em bits que são 0 *ou* 1, moldou nossa era, um novo paradigma emerge das profundezas da física subatômica. Nele, os *qubits* (bits quânticos) podem ser 0, 1 ou – de forma mais extraordinária – 0 *e* 1 simultaneamente. Este fenômeno, chamado *superposição*, é a primeira peça de uma revolução. Quando combinado com o *emaranhamento* – onde partículas se conectam de modo que o estado de uma define instantaneamente o da outra, independentemente da distância –, temos a base da computação quântica. Não se trata apenas de processadores mais rápidos, mas de uma máquina que opera sob uma lógica fundamentalmente diferente, explorando uma miríade de possibilidades paralelas em vez de seguir um único caminho sequencial. É como substituir uma estrada única por um universo de trajetórias simultâneas.

As implicações são tão vastas que redefinem horizontes. Na medicina, poderemos simular moléculas em nível atômico, acelerando a descoberta de medicamentos personalizados e tratamentos revolucionários. Na criptografia, a quebra de códigos atuais forçará a criação de protocolos invioláveis baseados na própria física quântica. Na logística e na inteligência artificial, problemas de otimização considerados intratáveis para os computadores atuais – como o roteamento perfeito de frotas globais ou a modelagem de sistemas climáticos caóticos – podem encontrar soluções em minutos. A promessa é redesenhar setores inteiros, da ciência de materiais à economia.

Neste cenário de futuros possíveis, o legado do físico e futurista **Michio Kaku** se ergue como um farol intelectual. Por décadas, Kaku atuou como uma ponte vital entre os complexos domínios da física teórica de ponta e a compreensão pública. Antes que a corrida quântica ganhasse as manchetes corporativas, ele já desvendava, em livros e palestras, os princípios dessa física “exótica”, contextualizando-a na grande narrativa da evolução tecnológica humana. Kaku não apenas explicou a mecânica quântica; ele a situou como o próximo salto civilizacional, argumentando que dominar a tecnologia quântica seria tão transformador e essencial quanto dominar o fogo, a roda, a eletricidade ou o silício.

Seu trabalho seminal de divulgação cumpriu um papel profundo: demitizarizar conceitos abstratos, traduzir esperanças e alertas, e preparar o terreno cultural e intelectual para que esta nova era fosse não apenas temida como uma caixa-preta ininteligível, mas sim compreendida, debatida e aguardada com um olhar crítico e esperançoso. Kaku nos ensinou a pensar em múltiplos futuros, antevendo um mundo onde a computação quântica se tornaria uma utilidade pública, uma ferramenta para enfrentar nossos maiores desafios, da cura de doenças à sustentabilidade do planeta.

A corrida para materializar essa visão já está em curso, acirrada e global. Gigantes como Google, IBM, Microsoft e Amazon, além de startups especializadas e potências nacionais, investem bilhões. Máquinas com centenas de *qubits* físicos são anunciadas, marcando marcos experimentais importantes. O Google proclamou a “supremacia quântica” ao realizar um cálculo específico inviável para supercomputadores clássicos, enquanto a IBM avança em seu roteiro para processadores quânticos cada vez mais robustos.

No entanto, o caminho até o computador quântico universal e verdadeiramente útil é íngreme e repleto de obstáculos monumentais. A *coerência quântica* – o estado frágil que permite aos *qubits* manter sua superposição e emaranhamento – é efêmera. Qualquer interferência mínima do ambiente (ruído térmico, radiação) causa a *decoerência*, fazendo o sistema colapsar para um estado clássico. Por isso, os processadores quânticos exigem ambientes de isolamento extremo, operando a temperaturas próximas do zero absoluto em criostatos complexíssimos.

Além do hardware, o desafio é de software e algoritmos. Precisamos de novos paradigmas de programação e algoritmos quânticos específicos (como o de Shor para fatoração ou o de Grover para busca) que explorem as vantagens quânticas. A correção de erros quânticos, que consome uma grande parte dos *qubits* físicos para criar *qubits* lógicos estáveis, é um dos maiores problemas em aberto. O “computador quântico útil” – aquele que resolverá problemas práticos de grande escala – ainda é uma meta no horizonte, estimada por muitos especialistas em talvez uma ou duas décadas.

O futuro, como Michio Kaku tanto explorou, será forjado por aqueles que dominarem não apenas a engenharia, mas os princípios desta física fundamental. Mais do que uma nova máquina, a computação quântica representa uma nova forma de pensar, de calcular e de interagir com a própria realidade. Ela nos força a confrontar as leis contra-intuitivas que governam o universo em sua menor escala e a aplicá-las em nosso mundo macro. A fronteira está aberta, não apenas para laboratórios e corporações, mas para uma geração de cientistas, engenheiros e pensadores que, inspirados por visionários como Kaku, se atrevem a programar o impossível e a calcular o desconhecido. A revolução quântica será, em última instância, uma revolução da imaginação humana aplicada.