Esta publicação faz parte de uma série para mostrar que muitos dos conceitos de desenvolvimento mainframe também estão presentes na distribuída. Neste post falarei sobre ferramentas.
Ferramentas e tecnologias
Existem algumas ferramentas e tecnologias que sempre estão presentes no ciclo de desenvolvimento de software de um dev mainframe:
TSO/ISPF Edit
File Edit Edit_Settings Menu Utilities Compilers Test Help
───────────────────────────────────────────────────────────────────────────────
EDIT ZOSUSER.EXAMPLE.FILE(TEST01) - 01.00 Columns 00001 00072
****** ***************************** Top of Data ******************************
==MSG> -Warning- The UNDO command is not available until you change
==MSG> your edit profile using the command RECOVERY ON.
''''''
''''''
''''''
''''''
''''''
''''''
''''''
''''''
''''''
''''''
''''''
''''''
''''''
''''''
''''''
Command ===> ________________________________________________ Scroll ===> CSR
F1=Help F2=Split F3=Exit F5=Rfind F6=Rchange
Provavelmente é uma das ferramentas mais utilizada pelos desenvolvedores mainframe. Seja para editar/visualizar código ou dados de arquivo, esta ferramenta é muito poderosa. Os primary commands e line commands proporcionam muitas funcionalidades: CHANGE, HILITE, SORT, FLIP, FIND, CUT and PASTE, entre muitos outros (lista de: primary commands e line commands).
Na distribuída também existem ferramentas de edição de texto com o mesmo perfil de funcionalidades, algumas mais outras menos, como por exemplo vi, vim, nano, notepad++, textpad, o simples e eficiente notepad, entre tantos outros. O legal é que alguns deles possuem funcionalidades ativadas por teclas de atalho ou por linha de comando, conceito parecido com o TSO/ISPF Edit.
vim:
notepad:
Porém, com a evolução das práticas de desenvolvimento de software, surgiram as IDE's (Integrated Development Environment). Estes programas são suites que reunem diversas ferramentas utilizadas no ciclo de desenvolvimento como: editor de texto, gerenciador de testes, terminal de linha de comando, REPL, versionador de arquivos, gerenciador de dependências, etc. As IDE's podem ser específicas para o ecossistema de uma determinada linguagem ou podem ser genéricas e atender mais de um tipo de linguagem de programação. Exemplos conhecidos de IDE: eclipse, visual studio, visual studio code, intellij, sublime, atom, pycharm e uma infinidade de outras.
pycharm IDE:
As IDE's são excelentes ferramentas para ganho de produtividade e o desenvolvimento no mainframe também evoluiu. Existem ferramentas como o RDZ (baseado no eclipse) e o IBM Z Open Editor em conjunto com o Zowe Editor (plugins para o Visual Studio Code) que permitem conexão direta com o mainframe e edição de código, com auto-complete de sintaxe, alertas de typos e muitas outras funcionalidades.
Conheça o IBM Z Open Editor.
Enfim, quem deseja migrar do TSO/ISPF Edit, fique tranquilo que outros editores ou IDE's possuem funcionalidades conhecidas de edição, é apenas uma questão de costume e prática que são rapidamente aprendidas.
JCL
//**********************************************************************
//* EXEMPLO DE JCL
//**********************************************************************
//JOBXPTO JOB 1
//STEP001 EXEC PGM=SORT
//SORTIN DD DISP=SHR,DSN=ZOSUSER.EXAMPLE.FILE
//SORTOUT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
SORT FIELDS=(1,10,CH,A)
/*
O JCL (Job Control Language), é uma linguagem de controle de JOB's. De uma maneira bem geral, o JOB orquestra um conjunto de STEP's que por sua vez executa um ou mais programas (PGM's ou PROC's). Cada STEP tem referência para um programa e seus respectivos inputs e outputs (arquivos, sysout de logs, etc).
Na distribuída também há algo similar e depende das instalações dos interpretadores de comandos presentes nos Sistemas Operacionais, também conhecidos por shell. Um mesmo Sistema Operacional pode ter um ou mais interpretadores de comandos.
Os shell's são programas que permitem interagir com o sistema operacional e podem fazer chamadas a outros programas, igual ao JCL. Alguns exemplos de shell's conhecidos: Bourne shell (sh), bash, powershell, batch (.bat do Windows) e o gitbash.
Cada shell possui uma linguagem e sintaxe própria. Podem invocar comandos diretamente na linha de comando ou então criar arquivos de script's com um conjunto de instruções. Os scripts fazem o que o JCL faz: orquestra execução de programas, possuem lógicas de processamento, podem ter comentários e podem ter referências a inputs e outputs dos programas.
A forma de declarar as instruções de um shell é diferente de um JCL, porém o conceito por trás deles tem pontos em comum.
Changeman
--- CHANGE MAN n.n.nn PRIMARY OPTION MENU --- NOTIFICATION UPDATED
OPTION ===>
1 Build - Create, update and review package data
2 Freeze - Freeze or unfreeze a package
3 Promote - Promote or demote a package
4 Approve - Approve or reject a package
5 List - Display (to process) package list
B Backout - Back out a package in production
C CDF - Concurrent Development Facility
D Delete - Delete or undelete a package
L Log - Browse the activity log
N Notify - Browse the Global Notification File
O OFMlist - Online Forms package list
Q Query - Query packages, components and relationships
R Revert - Revert a package to DEV status
T Tutorial - Display information about Change Man
X Exit - Exit Change Man
Press ENTER to process; enter END command to exit.
O nome remete ao seriado japonês que a Rede Manchete exibia no final dos anos 80. Quando resolvo algum bug em Produção, às vezes me lembro do personagem Gyodai deste seriado: assim que o problema é resolvido, algo acontece e ele volta maior 😅.
Voltando para o CHANGEMAN do mainframe, considero uma ferramenta incrível. Ela realiza versionamento de código, movimenta os tipos de códigos (programas, telas, copybooks, etc) para suas respectivas libs, promove os componentes para os ambientes corretos, gerencia aprovações, gerencia dependências de componentes, executa jobs para validação de qualidade (código, completude, testes), entre outras funcionalidades.
Na distribuída também existem ferramentas que possuem a mesma característica do CHANGEMAN. Alguns exemplos: Git, SVN, CVS e RTC.
Alguns destes exemplos precisam da combinação de outras ferramentas para ter os recursos completos do CHANGEMAN. Por exemplo, o Git permite realizar o versionamento de código de forma descentralizada. Porém para que possa ter o compartilhamento do projeto com outros membros do time é preciso ter um repositório central, como o github ou gitlab. E para que estes repositórios possam "promover" os programas, é preciso ter esteiras de implantação e deploy, normalmente feito através de scripts em ferramentas como o github actions ou o gitlab-ci.
github:
Atualmente na distribuída adota-se muito a prática de CI (Continuous Integration) e CD (Continuous Deploy), vale estudar o assunto. Acredito que se o CHANGEMAN for bem configurado, é possível replicar esta prática no mainframe também.
SORT, IEFBR14, ICEGENER, IEBGENER
//**********************************************************************
//** CREATE FILES **
//**********************************************************************
//STEP01 EXEC PGM=IEFBR14
//INPUT DD DSN=ZOSUSER.EXAMPLE.FILE,DISP=(NEW,CATLG,DELETE),
// SPACE=(TRK,0),UNIT=SYSDA,DCB=(RECFM=FB,LRECL=300,BLKSIZE=1024)
SORT, IEFBR14, ICEGENER, IEBGENER são alguns de muitos "utilitários" presentes no mainframe. Estes utilitários são programas que realizam tasks específicas e úteis, normalmente para manipulação de arquivo: criar, deletar, ordenar, extrair parte de registros, alterar parte de registros, entre outros.
Na distribuída também existem "utilitários" instalados junto com as distribuições dos sistemas operacionais e que realizam tarefas semelhantes às do mainframe.
Exemplos são os programas que acompanham distribuições Linux: sort, sed, cut, touch e rm que são apenas alguns dos comandos que realizam função semelhante às citadas dos utilitários mainframe. Além deles também existem muitos outros comandos, para conhecer mais dê um google por "Linux commands line list" ou "Linux commands line cheat sheet":
Utilizar estes "utilitários" juntamente com os scripts (comentado acima no tópico de JCL) é um jeito prático e poderoso para realizar tasks no sistema operacional, manipular arquivos e executar programas de forma automatizada.
SDSF
Display Filter View Print Options Help
------------------------------------------------------------------------------
ISPF. SDSF Primary Option Menu
COMMAND INPUT ===> _ SCROLL ===> PAGE
DA Active users INIT Initiators
I Input queue PR Printers
O Output queue PUN Punches
H Held output queue RDR Readers
ST Status of jobs LINE Lines
NODE Nodes
LOG System log SO Spool offload
SR System requests SP Spool volumes
MAS Members in the MAS
JC Job classes ULOG User session log
SE Scheduling environments
RES WLM resources
ENC Enclaves
PS Processes
END Exit SDSF
F1=HELP F2=SPLIT F3=EXIT F4=RETURN F5=IFIND F6=BOOK
F7=UP F8=DOWN F9=SWAP F10=LEFT F11=RIGHT F12=RETRIEVE
O SDSF (System Display and Search Facility) é uma ferramenta no ISPF muito utilizada para visualizar jobs em execução, verificar logs de execução e gerenciar jobs (hold, release, cancel, purge).
Na distribuída, os sistemas operacionais possuem ferramentas para visualizar os processos em execução. Alguns exemplos: no Windows existe o Task Manager (Gerenciador de tarefas), no Mac Task Manager (Monitor de atividades) e no Linux/Unix existem linhas de comandos que permitem visualizar as tasks por linha de comando ps aux e top.
command line top:
Processes: 395 total, 3 running, 392 sleeping, 2233 threads 21:14:37
Load Avg: 1.55, 2.06, 2.02 CPU usage: 0.96% user, 0.96% sys, 98.7% idle
SharedLibs: 182M resident, 58M data, 17M linkedit.
MemRegions: 100694 total, 5008M resident, 151M private, 1687M shared. PhysMem: 16G used (1929M wired), 86M unused.
VM: 2967G vsize, 1993M framework vsize, 528596(0) swapins, 563341(0) swapouts.
Networks: packets: 212079/191M in, 167807/28M out. Disks: 1644472/40G read, 390628/5110M written.
PID COMMAND %CPU TIME #TH #WQ #PORT MEM PURG CMPRS PGRP PPID STATE BOOSTS %CPU_ME
2171 top 3.2 00:00.66 1/1 0 25 3332K 0B 0B 2171 1460 running *0[1] 0.00000
1458 Terminal 2.2 00:13.00 9 4 252- 54M- 31M 0B 1458 1 sleeping *0[138] 0.27569
269 WindowServer 2.0 07:28.32 11 4 859+ 453M 36M 18M 269 1 sleeping *0[1] 0.65891
0 kernel_task 1.0 10:43.33 173/8 0 0 315M 0B 0B 0 0 running 0[0] 0.00000
178 hidd 0.5 01:40.01 6 3 233 5380K 0B 1092K 178 1 sleeping *0[1] 0.02443
1857 Python 0.3 00:02.34 3 0 20 19M 0B 0B 1849 1849 sleeping *0[1] 0.00000
2038 Python 0.3 00:01.92 3 0 20 22M 0B 0B 1849 1849 sleeping *0[1] 0.00000
Pelos Task Manager's ou pela linha de comando, existem funcionalidades para encerrar os processos em execução, parecido com o SDSF.
A diferença maior entre mainframe e distribuída fica na forma como os logs (sysout) são exibidos. No mainframe existe a opção de output para uma SYSOUT que é comum a todos os processos do mainframe e facilmente acessada pelo SDSF. Na distribuída, os programas costumam gravar os logs em arquivos ou, dependendo do tipo de aplicação, exibem na console de execução da própria aplicação.
log output de uma aplicação em python:
$
$python app.py
Starting application ...
INFO:root:Logging example - this is a info
WARNING:root:Other logging example - this is a warning!
ERROR:root:Oh no! This is a logging error!!!
Application terminated
$
EASYTRIEVE
EASYTRIEVE é uma linguagem de programação que pode ser interpretada no momento de execução após ser escrita em um cartão "inline" no JCL ou também pode ser compilada e processada como programa.
Na distribuída também existem linguagens de programação interpretadas. Uma das mais utilizadas atualmente é o javascript, linguagem empregada desde em engines de navegadores de internet até em engines de backend como o node.js, por exemplo.
É possível aplicar estas linguagens interpretadas juntamente com os shell scripts (comentado acima no tópico de JCL).
exemplo de script.sh, com chamada node em código javascript:
script.sh
echo "Inicio do shell script bash..."
node -e " \
var showMessage = true; \
console.log('Inicio código javascript'); \
if (showMessage) { \
console.log('Hello Mainframe World!'); \
} else { \
console.log('No message'); \
} \
console.log('Término código javascript'); \
"
echo "Término do shell script bash!"
log de saída do script.sh:
Inicio do shell script bash...
Inicio código javascript
Hello Mainframe World!
Término código javascript
Término do shell script bash!
No exemplo acima, o comum é que o código javascript ficasse em um arquivo à parte. Porém, o exemplo foi feito apenas como comparação com o EASYTRIEVE. A forma dinâmica de fazer código interpretado ou compilado que existe no mainframe, também pode ser aplicada na distribuída.
FILE-AID
File-AID - Browse - USEROS.EXAMPLE.FILE ------------------- LINE 0000 COL 1 1
COMMAND ===> SCROLL ===> PAGE
COD-IDENTI NOME IDADE DT-NASCIM FILLER
5/AN 15/AN 3/AN 10/AN 17/AN
(1-5) (6-20) (21-23) (24-33) (34-50)
1--------- 2-------------- 3------------- 4----------- 5-----------------------
********************************* TOP OF DATA **********************-CAPS OFF-*
00001 FULANO 20 01/01/2001
00002 CICLANO 30 10/10/1991
00003 BELTRANO 40 12/12/1981
******************************** BOTTOM OF DATA ********************-CAPS OFF-*
O FILE-AID é uma ferramenta essencial no dia-a-dia de quem trabalha com muitos arquivos no mainframe. Pela natureza dos arquivos no mainframe terem formato posicionais baseados em copybooks, o FILE-AID facilita a visualização e edição dos dados.
Os arquivos utilizados na distribuída possuem uma natureza diferente, normalmente são arquivos do tipo csv (Comma Separated Values). Estes arquivos possuem seus valores separados por vírgulas ou algum outro caracter delimitador.
exemplo de arquivo posicional:
00001FULANO 02001/01/2001
00002CICLANO 03010/10/1991
00003BELTRANO 04012/12/1981
mesmo arquivo, porém em formato csv:
codigo-identificador,nome,idade,data-nascimento
00001,FULANO,20,01/01/2001
00002,CICLANO,30,10/10/1991
00003,BELTRANO,40,12/12/1981
(os arquivos csv podem ou não vir acompanhados do cabeçalho)
Na distribuída uma ferramenta muito versátil e conhecida para visualizar este tipo de conteúdo é o Microsoft Excel. Ele permite converter arquivos posicionais ou csv em formatação tabular, o que facilita muito a visualização e filtros de dados.
A opção no Excel para realizar estas conversões é o Dados > Texto para Colunas.
Ao converter um arquivo posicional para tabela, escolha a opção Largura Fixa:
E ao converter um arquivo csv para tabela, escolha a opção Delimitado:
Existem outros programas que também permitem visualizar este tipo de conteúdo, vale pesquisar. Além disso, na distribuída também existem outros formatos de arquivos, vale verificar sempre o sufixo dos arquivos (também chamado de extensão do arquivo). Para cada extensão há diferentes aplicações.
O objetivo deste post é reforçar que apesar das plataformas mainframe e distribuída serem distintas, a maneira de trabalhar é muito parecida. Existem ferramentas similares nos dois mundos.
O grande desafio na transição do mainframe para a distribuída é descobrir as tecnologias existentes e aprendê-las. Acredito que o segredo para facilitar este aprendizado é descobrir os sinônimos de nomes e jargões entre as duas plataformas. A partir disso, ir atrás das ferramentas e tecnologias.
Depois que aprender: usar caspeta, batucar e gerar um arquivo dummy serão fáceis de fazer em qualquer lugar!
Glossário
caspeta: aspas
batucar: codar
arquivo dummy: arquivo vazio
Indice
- Ambiente
- Ferramentas (este post)
- Linguagens de programação. Exemplo: Cobol vs Python (em breve)
- Setup de ambiente Python: Hello World! (em breve)
Oldest comments (0)