Mainframe e Distribuída - parte 2 - Ferramentas
Tags: mainframe, programming
Published: 2022-01-07 02:03:05

&nbsp; 

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](#tsoispf-edit)
- [JCL](#jcl)
- [Changeman](#changeman)
- [SORT, IEFBR14, ICEGENER, IEBGENER](#sort-iefbr14-icegener-iebgener)
- [SDSF](#sdsf)
- [EASYTRIEVE](#easytrieve)
- [FILE-AID](#fileaid)

&nbsp; 

### 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](https://www.ibm.com/docs/en/zos/2.1.0?topic=reference-edit-primary-commands) e [line commands](https://www.ibm.com/docs/en/zos/2.1.0?topic=reference-edit-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](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wahtj6n0rgjk0iuyut3r.png)

notepad:
![windows notepad screen](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/r086wxdx0o9n3b1gke55.png)
 
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](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rgx7iy4lzl0usa5ihahi.png)
 
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](https://ibm.github.io/zopeneditor-about/).

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.

&nbsp;

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

&nbsp; 

### 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:
![github screen](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d8wbmr28onsmkf41i13e.png)
 

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.

&nbsp; 

### 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":
- [Linux-Cheat-Sheet-Sponsored-By-Loggly.pdf](https://www.loggly.com/wp-content/uploads/2015/05/Linux-Cheat-Sheet-Sponsored-By-Loggly.pdf)
- [Fedora Magazine Command line quick tips](https://fedoramagazine.org/command-line-quick-tips-wc-sort-sed-and-tr/)

Utilizar estes "utilitários" juntamente com os `scripts` (comentado acima no tópico de [JCL](#jcl)) é um jeito prático e poderoso para realizar tasks no sistema operacional, manipular arquivos e executar programas de forma automatizada.

&nbsp; 

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

$
```

&nbsp; 

### 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](#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.

&nbsp; 

### 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`.
![opção Texto para Colunas do Excel](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rzn33es143v1pn0cqkyn.png)

Ao converter um arquivo posicional para tabela, escolha a opção `Largura Fixa`:
![opção Largura Fixa na conversão de Texto para Colunas](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c1ic8flgqk910u5p1z06.png)

E ao converter um arquivo csv para tabela, escolha a opção `Delimitado`:
![opção Delimitado na conversão de Text para Colunas](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/chzgbq3jv8yu87andj1r.png)

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](https://dev.to/sug/retroceder-nunca-abendar-jamais-i-12fo/edit)
- **Ferramentas** (este post)
- *Linguagens de programação. Exemplo: Cobol vs Python* (em breve)
- *Setup de ambiente Python: Hello World!* (em breve)

&nbsp;