DEV Community: rogeriosug

Mainframe e Distribuída - parte 3 - Linguagens

rogeriosug — Sun, 27 Aug 2023 03:31:14 +0000

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 linguagens de programação.

Linguagens de programação

Quando se fala de linguagem de programação no mainframe, entre as mais populares temos COBOL, CICS e DB2. Além de PL/I IMS/DC, IMS/DB, VSAM, NATURAL, ADABAS, e várias outras.

Até mesmo Java, C e C++, muito conhecidas na distribuída, também podem ser encontradas no mainframe.

Vale lembrar um pouco da história da programação na alta plataforma (mainframe), os conceitos de linguagem e ciclo de desenvolvimento são universais.

Cartão perfurado

Já ouviu a expressão "programar em papel de pão"? O início do desenvolvimento de software no mainframe não estava muito longe disso, a programação era feita em cartões perfurados.

Cada cartão perfurado representava uma linha de código. Caso fosse arquivo a ser processado, cada cartão representava uma linha deste arquivo.

Cada cartão tinha um limite de 80 colunas.

No momento de processar os cartões, eles precisavam estar ordenados. Imagina a bagunça se alguém mudasse a ordem dos cartões (por conta disso as linguagens continham colunas reservadas para identificar a posição do código).

Por conta disso, os desenvolvedores na época precisavam:

fazer códigos enxutos: códigos simples, organizados, de fácil manutenibilidade, com reaproveitamento de código. Assim, refletia em menos cartões, menos tempo de compilação, menos processamento e menor custo;
codificar em uma quantidade limitada de colunas, por conta da limitação dos cartões, mas que de certa forma ajudava em um código mais legível;
ter a consciência de que quanto mais complexo fosse o código, mais difícil seriam refatorações futuras e a inclusão de novas regras de negócio.

Coincidentemente, todos estes pontos adotados por conta de limitações da arquitetura da época, hoje são adotados no ciclo de desenvolvimento de software por motivos de boas práticas de programação e finops.

COBOL

Uma das linguagens mais utilizadas no mainframe é o COBOL. O COBOL é uma linguagem estruturada em DIVISIONs, SECTIONs e PARAGRAPHs. Este formato de estrutura facilita muito a localização de partes do código e sua manutenção.

Mas olhando de uma maneira geral, o COBOL não é diferente de qualquer outra linguagem da plataforma distribuída. Basta olhar para as DIVISIONs que são o nível mais alto da linguagem. Elas são distribuídas em IDENTIFICATION DIVISION, ENVIRONMENT DIVISION, DATA DIVISION e PROCEDURE DIVISION, respectivamente representam:

parte do código que identifica o programa
configurações e interfaces de I/O do programa
variáveis utilizadas pelo programa
código e lógica do programa

Ou seja, tudo que existe em outras linguagens de programação.

Diferenças entre linguagens de alta e baixa plataforma

Romantismo à parte, ao retirarmos estas limitações herdadas do passado, as linguagens do mainframe não se diferenciam das utilizadas na distribuída. Até mesmo existem linguagens que foram portadas de uma plataforma para outra.

Lógica de programação, estrutura de dados, declaração de variáveis, alocação de memória, estruturas condicionais (if-else), operadores lógicos (and-or-not), entre outros recursos, são comuns entre as linguagens independente da plataforma.

A sintaxe da linguagem podem ser diferentes, porém os conceitos por trás delas são iguais. Para quem conhece mais da plataforma mainframe e quer for explorar as tecnologias mais recentes, é preciso estudo e curiosidade. Boas fontes de informação são: documentações oficiais, tutoriais, livros, podcasts e video-aulas.

Além de estudar a sintaxe de uma linguagem nova, vale investir um tempo para aprender as arquiteturas e ferramentas por trás das plataformas:

Da mesma forma que no mainframe você já deve ter vivenciado a necessidade em aprender a usar o TSO, ROSCOE, REXX, o esforço vai ser parecido em desvendar Linux, Unix, AWS, Azure, etc.

E quem já trabalhou com VSAM? Algum dia já teve que começar a trabalhar com DB2 ou até mesmo com banco de dados não-relacionais, como ADABAS ou IMS/DB? O esforço não vai ser muito diferente de ter que aprender MongoDB, MySQL, SQLServer, entre muitos outros.

Ou então ter que aprender a mapear e desenvolver telas com IMS ou CICS? O esforço vai existir também para aprender um pouco sobre HTML, CSS, React, Angular e até mesmo frameworks ou linguagens nativas para dispositivos mobile.

Falando em CICS, muito utilizado para aplicações transacionais online, também podemos colocar na lista o conhecimento que se adquire ao aprender sobre requisições REST, API's, GRPC.

Existem bastante analogias entre o mainframe e a plataforma distribuída. A dica é sempre entender o conceito por trás das tecnologias, todas no final convergem para o mesmo lugar: resolver alguma necessidade ou problema.

E se você está migrando do mainframe agora, não tente aprender tudo de uma vez. Foque em algumas tecnologias, se dedique a elas e o resto virá naturalmente. Desenvolva projetos pessoais ou profissionais, pratique! O principal você já tem: lógica de programação e conceitos de máquina.

Paradigmas de programação

Para navegar com mais tranquilidade nos estudos de novas linguagens de programação, um capítulo importante para aprender são os Paradigmas de Programação.

A maior parte dos programas existentes no mainframe atualmente adotam o paradigma de programação procedural. É um paradigma derivado do paradigma imperativo e utiliza chamadas em procedures, que são conjunto de códigos agrupados em subrotinas ou estruturas de códigos.

Ao estudar novas linguagens de programação mais recentes, é interessante ter o conhecimento mínimo de outros paradigmas de programação, alguns deles: programação orientada a objetos, programação funcional, programação orientada a eventos e programação reativa.

Seguem alguns links de referência:

Wikipedia: Comparison of programming paradigms

Wikipedia: List of programming languagens by type

Mainframe e Distribuída - parte 2 - Ferramentas

rogeriosug — Fri, 07 Jan 2022 02:03:05 +0000

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
JCL
Changeman
SORT, IEFBR14, ICEGENER, IEBGENER
SDSF
EASYTRIEVE
FILE-AID

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)

Mainframe e Distribuída - parte 1 - Ambiente

rogeriosug — Sat, 01 Jan 2022 14:50:59 +0000

Desenvolvedores que trabalham exclusivamente com mainframe podem sentir alguns impactos quando começam a explorar o universo da computação distribuída.

Este post é o primeiro de uma série para auxiliar os devs nesta transição e perceberem que muitos dos conceitos conhecidos no mainframe estão presentes na distribuída: mudam-se a panela e o fogão, mas o sabor da comida continua o mesmo.

Sobre esta série de posts

O objetivo final destes posts é tentar ajudar quem já conhece o ambiente mainframe e quer explorar o ambiente distribuído, também conhecido como baixa plataforma.

Este texto não tem a intenção de ser um guia exaustivo, ele tem o objetivo de dar algumas noções iniciais e incentivar nos estudos. Nos comentários abaixo, fiquem à vontade para sugerir correções e complementar com mais informações.

No final existe um glossário e também um índice com os tópicos da série. Esta série está em evolução e novos tópicos surgirão.

Ambiente

Sistema Operacional

Todo hardware precisa de um sistema operacional que possa gerir os recursos disponíveis. No mainframe são conhecidos o MVS, OS/390 e atualmente um dos mais predominante é o z/OS.

Na distribuída, atualmente, os mais conhecidos são o Windows, Linux e macOS.

A grande diferença é a arquitetura: no mainframe os usuários interagem com o sistema operacional em sessões virtuais através de terminais como os emuladores de terminais 3270. Já na distribuída os usuários interagem diretamente com o sistema operacional.

Existem funcionalidades comuns entre os sistemas operacionais, por exemplo da mesma maneira que o z/OS possui o RACF que gerencia permissões de autenticação e acesso, os sistemas operacionais da distribuída também possuem a implementação desta funcionalidade. Este mesmo conceito de segurança também existe nas plataformas de cloud, como o IAM da AWS.

Interface gráfica e não tão gráfica

No mainframe, assim que o desenvolvedor faz login no TSO, ele pode invocar linhas de comando como CLIST e REXX ou então pode chamar uma interface como o ISPF (ou PDF). Outra interface conhecida no mainframe é o ROSCOE.

Menu Utilities Compilers Options  Status  Help
------------------------------------------------------------------------------
                           ISPF Primary Option Menu
Option ===>

0  Settings      Terminal and user parameters            User ID .: USER
1  View          Display source data or listings         Time. . .: 00:00
2  Edit          Create or change source data            Terminal.: 3278
3  Utilities     Perform utility functions               Screen. .: 1
4  Foreground    Interactive language processing         Language.: ENGLISH
5  Batch         Submit job for language processing      Appl ID .: PDF
6  Command       Enter TSO or Workstation commands       TSO logon: ACCT
7  Dialog Test   Perform dialog testing                  TSOprefix: USER
8  LM Facility   Library administrator functions         System ID: SC04
9  IBM Products  IBM program development products        MVS acct.: ACCNT#
10 SCLM          SW Configuration Library Manager        Release .: ISPF 5.2
11 Workplace     ISPF Object/Action Workplace
M  More          Additional IBM Products

Enter X to Terminate using log/list defaults

F1=Help F2=Split F3=Exit F7=Backward F8=Forward F9=Swap F10=Actions F12=Cancel

Ao fazer um paralelo com a distribuída, existem as interfaces conhecidas por terminais que permitem interagir por linha de comando da mesma maneira que o TSO faz
E paralelo ao ISPF existem as interfaces gráficas, também conhecidas como GUI (Graphical User Interface), que são as telas em "janelas" que estamos acostumados a utilizar no dia-a-dia no Windows, Mac ou Linux.

Exemplos de terminais de linha de comando são: bash, sh, powershell, entre outros.

Exemplo de interface gráfica:

Existem outras funcionalidades semelhantes entre os dois mundos. Tanto o sistema operacional do mainframe quanto os da distribuída possuem gerenciadores de arquivos ou, no caso do mainframe, datasets. No ISPF os datasets podem ser visualizados na opção 1 (View) ou então na opção 3.4 (Utilities > DSLIST)

--------------------------  UTILITY SELECTION MENU  ----------------------------
OPTION ===> 4

    1  LIBRARY     - Compress or print data set.  Print index listing.
                       Print, rename, delete, or browse members
    2  DATASET     - Allocate, rename, delete, catalog, uncatalog, or
                       display information of an entire data set
    3  MOVE/COPY   - Move, copy, or promote members or data sets
    4  DSLIST      - Print or display (to process) list of data set names
                       Print or display VTOC information
    5  RESET       - Reset statistics for members of ISPF library
    6  HARDCOPY    - Initiate hardcopy output
    8  OUTLIST     - Display, delete or print held job output
    9  COMMANDS    - Create/change an application command table
   10  CONVERT     - Convert old format messages/menu panels to new format
   11  FORMAT      - Format definition for formatted data Edit/Browse
   12  SUPERC      - Compare data sets (Standard dialog)
   13  SUPERCE     - Compare data sets (Extended dialog)
   14  SEARCH-FOR  - Search data sets for strings of data

-----------------------------  DATA SET LIST UTILITY  --------------------------
OPTION ===>

  blank - Display data set list *              P  - Print data set list
  V     - Display VTOC information only        PV - Print VTOC information only

Enter one or both of the parameters below:
  DSNAME LEVEL  ===>  PREFIX
  VOLUME        ===>


  INITIAL DISPLAY VIEW   ===>  VOLUME  (VOLUME,SPACE,ATTRIB,TOTAL)
  CONFIRM DELETE REQUEST ===>  YES    (YES or NO)

* The following line commands will be available when the list is displayed

B - Browse data set        C - Catalog data set        F - Free unused space
E - Edit data set          U - Uncatalog data set      = - Repeat last command
D - Delete data set        P - Print entire data set
R - Rename data set        X - Print index listing
I - Data set information   M - Display member list
S - Information (short)    Z - Compress data set       TSO command or CLIST

DSLIST - DATA SETS BEGINNING WITH PREFIX ---------------------------  ROW 1 OF 9
COMMAND ===>                                                    SCROLL ===> PAGE
COMMAND      NAME                                      MESSAGE            VOLUME
-------------------------------------------------------------------------------
         PREFIX.$10$09$5                                                  MAR87B
         PREFIX.$15$38$5                                                  OCT87A
         PREFIX.ABDRVR7.ISPPLIB                                           FEB87B
         PREFIX.CURRENT.BILLS                                             TSO007
         PREFIX.MEMO.TEXT                                                 NOV87C
         PREFIX.MY.CLIST                                                  TSO005
         PREFIX.SAMPLE.TEXT                                               MIGRAT
         PREFIX.TEST.COBOL                                                MIGRAT
         PREFIX.TEST.DATA                                                 NOV87C
*************************** END OF DATA SET LIST *******************************

De forma semelhante podemos visualizar os arquivos na distribuída tanto pela linha de comando (bash) ...

... quanto pela interface gráfica

Spoiler: não se preocupe com os comandos do terminal por enquanto, voltaremos nele futuramente

Aqui vale destacar a diferença estrutural entre datasets (mainframe) e arquivos (distribuída):

datasets: são formado por qualificadores de no máximo 8 caracteres e separados por "." (ponto) e o tamanho máximo do nome não pode exceder 44 caracteres. Exemplo: USERZOS.ARQUIVO.TESTE.EXEMPLO. Os datasets ainda podem ser PARTITIONED e permitem ter MEMBERS dentro deles, na distribuída, é como se fossem arquivos dentro de uma pasta

arquivos: são estruturados em pastas e sub-pastas. Os nomes dos arquivos geralmente são compostos por um prefixo e um sufixo (extensão), onde este sufixo indica o tipo de arquivo (.exe, .txt, .sh, .jpeg, .mp3).

Não é obrigatório que um arquivo tenha prefixo ou um sufixo, mas precisa pelo menos ter um deles. Exemplo: /pasta/sub-pasta/arquivo.txt, /pasta/sub-pasta/.gitignore, /pasta/sub-pasta/config

Como podemos ver, existem muitas similaridades entre as plataformas alta e baixa. Explore e faça este exercício.

Esta primeira parte da série é apenas para quebrar o gelo e abrir caminho para conhecermos outros conceitos em comum.

Nos próximos posts veremos que ferramentas de terceiros ou built-in do mainframe também possuem um similar na distribuída. Exemplos destas ferramentas são o CHANGEMAN, ENDEVOR, TSO EDITOR, DFSORT, FILE-AID, IEFBR14, ICEGENER, EASYTRIEVE, entre outras.

Mudam-se a panela e o fogão, mas o sabor da comida continua o mesmo.

Glossário

baixa plataforma: computação distribuída
alta plataforma: mainframe