DEV Community 👩‍💻👨‍💻

Cover image for Mainframe vs Distribuída - parte II - Ferramentas
rogeriosug
rogeriosug

Posted on • Updated on

Mainframe vs Distribuída - parte II - Ferramentas

 

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.

Esta série está em evolução e novos tópicos surgirão.

Spoiler: a partir do quarto episódio teremos hands-on, afinal, codar é preciso


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 
Enter fullscreen mode Exit fullscreen mode

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:
vim screen

notepad:
windows notepad screen

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:
pycharm screen

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)
/*
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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:
github screen

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) 
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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

$
Enter fullscreen mode Exit fullscreen mode

 

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!"
Enter fullscreen mode Exit fullscreen mode

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!
Enter fullscreen mode Exit fullscreen mode

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-*
Enter fullscreen mode Exit fullscreen mode

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                 
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

(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.
opção Texto para Colunas do Excel

Ao converter um arquivo posicional para tabela, escolha a opção Largura Fixa:
opção Largura Fixa na conversão de Texto para Colunas

E ao converter um arquivo csv para tabela, escolha a opção Delimitado:
opção Delimitado na conversão de Text para Colunas

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)

 

Top comments (0)

Timeless DEV post...

How to write a kickass README

Arguably the single most important piece of documentation for any open source project is the README. A good README not only informs people what the project does and who it is for but also how they use and contribute to it.

If you write a README without sufficient explanation of what your project does or how people can use it then it pretty much defeats the purpose of being open source as other developers are less likely to engage with or contribute towards it.