 |
| Bellacosa Mainframe nostalgico relembrando velharias do passado Microsoft Cobol |
☕ Um Café no Bellacosa Mainframe
Microsoft COBOL-80 sem Mistérios
Quando um Programador COBOL Descobre que a Microsoft Já Vendia Compiladores Antes de Tentar Reiniciar o Universo
Existe uma antiga lenda tecnológica, preservada em fitas magnéticas, manuais amarelados e salas onde o ar-condicionado jamais foi desligado, segundo a qual a história da Microsoft começou com o Windows.
Essa lenda está errada.
Profundamente errada.
Errada no mesmo nível de um programa COBOL que compila sem erros, executa com MAXCC=0000, produz um relatório impecavelmente formatado e deposita o salário de toda a diretoria na conta do estagiário.
Muito antes do Windows, do Word, do Excel, do Teams, do Azure e daquela mensagem dizendo que o computador será reiniciado em um horário que você não escolheu, a Microsoft era conhecida principalmente como uma fornecedora de linguagens de programação.
E entre essas linguagens existia o Microsoft COBOL-80.
Sim, jovem padawan do mainframe: a Microsoft já vendeu COBOL.
Não um plugin obscuro criado por três monges em um porão. Não um interpretador experimental encontrado em um disquete escrito “NÃO FORMATAR”. Estamos falando de um compilador comercial, documentado e destinado aos microcomputadores que começavam a surgir no final da década de 1970.
As três imagens desta nossa expedição mostram justamente esse pequeno portal temporal:
o manual do Microsoft COBOL-80;
o compilador sendo executado em um ambiente emulado;
o painel frontal de um IMSAI 8080, uma das máquinas mais emblemáticas da primeira geração dos microcomputadores.
Coloque a toalha sobre o ombro, verifique se o café está quente e evite entrar em pânico. Vamos viajar até uma época em que 64 KB eram considerados um universo computacional inteiro.
 |
| Bellacosa Mainframe apresenta o Microsoft Cobol |
Capítulo 1 — O manual que veio antes do Windows
A primeira imagem apresenta a capa do:
Microsoft COBOL-80 Reference Manual
Na parte inferior aparece:
© Microsoft, 1978
A capa é simples, quase ascética. Não existe fotografia de banco de imagens mostrando executivos sorrindo diante de gráficos. Não há nuvens, robôs, inteligência artificial, transformação digital ou uma seta apontando para o infinito.
Há apenas o nome da empresa, o nome do produto e a expressão reference manual.
Naquela época, o manual era parte essencial da ferramenta.
Hoje, quando um programador não entende um comando, ele pode consultar:
documentação on-line;
fóruns;
vídeos;
repositórios;
mecanismos de busca;
assistentes de inteligência artificial;
aquele colega que responde “aqui funciona” e desaparece.
Em 1978, o manual era o oráculo.
Ele precisava explicar os comandos, as estruturas da linguagem, as limitações do compilador, o formato dos arquivos, as mensagens de erro e o processo necessário para transformar um programa-fonte em alguma coisa executável.
Perder o manual era quase tão grave quanto perder o programa.
A documentação não era um complemento decorativo. Era parte do sistema.
Para um programador COBOL iniciante, essa é a primeira grande lição desta viagem:
Linguagem, compilador, sistema operacional e documentação formam um conjunto.
Você não programa apenas “em COBOL”. Você programa usando uma determinada implementação de COBOL, em determinado ambiente, com determinados limites.
Um programa escrito para IBM Enterprise COBOL em z/OS pode utilizar recursos que não existem no Microsoft COBOL-80. Da mesma forma, um programa criado para um compilador de microcomputador pode empregar extensões particulares que não seriam aceitas em outro ambiente.
O COBOL possui padrões, mas os compiladores vivem no mundo real.
E o mundo real gosta de acrescentar opções, restrições, peculiaridades e pequenas armadilhas capazes de manter consultores empregados durante décadas.
Capítulo 2 — A Microsoft antes de dominar as janelas
No imaginário popular, a Microsoft é associada ao sistema operacional Windows.
Entretanto, a empresa nasceu no mundo das linguagens.
Bill Gates e Paul Allen ganharam notoriedade inicial com uma implementação de BASIC para o Altair 8800. Em seguida, a Microsoft ampliou sua oferta de ferramentas de desenvolvimento para diferentes microcomputadores.
Naquele universo, uma empresa de software precisava fornecer aquilo que permitia transformar uma máquina vazia em uma máquina útil:
interpretadores;
compiladores;
montadores;
ferramentas de desenvolvimento;
rotinas de suporte;
bibliotecas.
O Microsoft COBOL-80 fazia parte dessa fase.
O nome “COBOL-80” não significa necessariamente que a linguagem tenha sido criada em 1980. A documentação mostrada é de 1978, e a versão exibida na tela possui uma data de 1980. O número também remete à família de processadores e ao ecossistema de microcomputadores de 8 bits que orbitava máquinas baseadas no Intel 8080 e no Zilog Z80.
Esse detalhe é importante.
O COBOL nasceu no final da década de 1950 para atender necessidades comerciais e administrativas. Inicialmente, sua imagem estava associada a grandes computadores utilizados por governos, bancos, seguradoras e corporações.
O COBOL-80 ajudou a transportar essa mentalidade para os microcomputadores.
Era como pegar uma criatura acostumada a viver em um oceano de salas refrigeradas e convencê-la a morar dentro de uma caixa sobre uma escrivaninha.
A criatura reclamou.
Mas coube.
 |
| Bellacosa Mainframe e o lendario processador intel 8080 |
Capítulo 3 — O que era um microcomputador em 1978?
Hoje, a palavra “microcomputador” pode soar antiga. Entretanto, na década de 1970, ela era quase revolucionária.
Os computadores comerciais tradicionais eram caros, grandes e normalmente operados por equipes especializadas. O acesso podia ocorrer por terminais, cartões perfurados ou lotes de processamento.
O microcomputador surgiu com uma promessa quase subversiva:
Uma pessoa, uma pequena empresa ou uma escola poderá possuir seu próprio computador.
Naturalmente, o “computador pessoal” daquele período não se parecia muito com um notebook moderno.
Muitas máquinas eram adquiridas em kits. Algumas exigiam montagem. Outras chegavam praticamente sem software. Em certos casos, o usuário precisava inserir manualmente um pequeno programa de inicialização utilizando chaves no painel frontal.
Não havia um assistente dizendo:
Olá! Vamos concluir a configuração do seu dispositivo.
Havia luzes.
Havia interruptores.
Havia silêncio.
E havia a certeza de que, se alguma coisa desse errado, o fabricante provavelmente estava a três estados de distância e também não sabia exatamente por que.
 |
| Bellacosa Mainframe apresenta o IMSAI 8080 |
Capítulo 4 — O IMSAI 8080 e o painel que parecia controlar uma nave
A terceira imagem mostra um IMSAI 8080 Microcomputer System.
Observe o nome com atenção: IMSAI, não “MSAI”.
Essa máquina surgiu como um dos sistemas compatíveis com a arquitetura popularizada pelo Altair 8800. Tornou-se uma das imagens clássicas da computação pessoal dos anos 1970 graças ao seu painel frontal repleto de chaves vermelhas e azuis.
Para um observador moderno, o painel parece pertencer a uma nave espacial fabricada por uma civilização que dominava viagens interestelares, mas ainda não havia descoberto o teclado.
As chaves permitiam controlar diretamente operações fundamentais da máquina.
No painel aparecem indicações como:
EXAMINE;DEPOSIT;RESET;RUN;STOP;SINGLE STEP;POWER ON;POWER OFF.
Também existem luzes associadas ao barramento de endereços, ao barramento de dados e aos estados de execução.
Vamos traduzir isso para a linguagem de um programador iniciante.
Examine
Permitia observar o conteúdo de uma determinada posição de memória.
Em termos conceituais, era como perguntar:
O que existe neste endereço?
Hoje, um depurador mostra variáveis, registradores, memória e pilha em janelas organizadas. No IMSAI, você examinava os bits por meio das luzes do painel.
Deposit
Permitiria gravar um valor em uma posição de memória.
Era possível selecionar um endereço, definir os bits e depositar um byte.
Depois você avançava para o próximo endereço.
E repetia o processo.
E repetia.
E reconsiderava todas as decisões que o haviam conduzido à carreira de tecnologia.
Single Step
Executava uma instrução por vez.
Esse recurso é ancestral direto do “step into” e do “step over” dos depuradores modernos.
O conceito não mudou:
execute uma instrução;
observe o estado da máquina;
tente compreender o que aconteceu;
culpe o compilador;
descubra que o erro era seu.
Run
Iniciava a execução normal.
Era o equivalente físico de liberar o programa para correr pela memória, carregando consigo toda a confiança injustificada do desenvolvedor.
Capítulo 5 — Digitar programas usando chaves
Nas primeiras configurações, antes de carregar um sistema operacional completo, o usuário podia precisar inserir um pequeno programa inicial diretamente pelo painel.
Esse programa era chamado de bootstrap ou bootstrap loader.
Sua função era carregar algo maior a partir de um dispositivo disponível, como fita de papel, cassete, disquete ou outro meio.
Imagine que você queira carregar um sistema operacional.
Mas para ler o sistema operacional você precisa de um programa.
E esse programa ainda não está na memória.
Logo, você precisa colocar manualmente o primeiro pequeno programa na máquina.
É o equivalente tecnológico de precisar construir uma escada para alcançar o manual que explica como construir escadas.
O operador ajustava as chaves para representar valores binários.
Por exemplo:
00111110
Cada chave correspondia a um bit: zero ou um.
O valor era depositado em uma posição da memória. Depois vinha o próximo byte. Depois o próximo.
Uma sequência errada poderia impedir a inicialização.
Não aparecia:
Syntax error near line 17
A máquina apenas não fazia aquilo que você esperava.
O que, curiosamente, continua sendo o comportamento predominante de grande parte do software moderno.
Capítulo 6 — O emulador e a segunda imagem
A segunda imagem mostra um ambiente que reproduz um computador antigo. Há uma janela de terminal marcada como CRT e uma representação virtual do painel de controle.
Na tela aparecem comandos e nomes de arquivos relacionados ao COBOL.
É possível identificar algo semelhante a:
COBLIB
COBOL
COBOL1
COBOL2
COBOL3
COBOL4
E, mais abaixo:
COBOL-80 V4.01
30-SEP-80
COPYRIGHT 1979,80 (C) MICROSOFT
Essa tela é extraordinária porque materializa o elo entre o manual de 1978 e a execução do compilador.
Não estamos apenas olhando para uma capa histórica. Estamos vendo um software daquela geração sendo executado em um ambiente preservado ou emulado.
A versão apresentada é a 4.01, datada de setembro de 1980.
Isso demonstra que o produto teve evolução. Ele não foi apenas uma experiência isolada lançada em um envelope e imediatamente esquecida atrás de uma copiadora.
O compilador possuía módulos e arquivos auxiliares. Em um ambiente de memória extremamente limitada, programas complexos eram frequentemente divididos em várias fases.
Um compilador precisava realizar tarefas como:
ler o código-fonte;
reconhecer palavras e símbolos;
analisar a estrutura da linguagem;
validar definições;
construir tabelas internas;
gerar código intermediário ou código de máquina;
produzir listagens e mensagens;
integrar rotinas necessárias;
criar um programa executável.
Hoje, podemos imaginar todas essas etapas executadas por um único processo que consome centenas de megabytes.
Naquele período, o compilador precisava trabalhar dentro de um espaço muito menor.
Dividir o processo em módulos não era um capricho arquitetural.
Era sobrevivência.
Capítulo 7 — O universo inteiro dentro de 64 KB
Processadores como o Intel 8080 possuíam um espaço de endereçamento de 16 bits.
Com 16 bits, podemos representar:
2¹⁶ = 65.536
Portanto, o espaço máximo diretamente endereçável era de 65.536 bytes, ou 64 KB.
Mas não conclua que o programador tinha todos esses 64 KB livres.
Dentro desse espaço podiam precisar coexistir:
sistema operacional;
programa;
dados;
buffers;
pilha;
rotinas de entrada e saída;
tabelas internas;
áreas reservadas ao hardware.
É como alugar um apartamento de 64 metros quadrados e descobrir que 20 metros pertencem ao condomínio, 10 estão ocupados pela caldeira e o compilador decidiu trazer três parentes para morar na sala.
Por isso, eficiência era essencial.
O programador precisava considerar:
tamanho dos registros;
quantidade de buffers;
organização dos arquivos;
tamanho do programa;
uso de sobreposições;
chamadas de módulos;
espaço disponível para execução.
Hoje, muitos programadores consideram memória apenas quando o sistema começa a consumir 14 GB para exibir uma lista de clientes.
Naquela época, cada byte tinha currículo, endereço fixo e autorização formal para permanecer no sistema.
Linha do tempo dos microprocessadores dos anos 70
| Ano | Microprocessador | Bits | Clock típico | Curiosidade |
|---|---|---|---|---|
| 1971 | Intel 4004 | 4 bits | 740 kHz | Primeiro microprocessador comercial do mundo |
| 1972 | Intel 8008 | 8 bits | 500–800 kHz | Primeiro CPU de uso mais geral da Intel |
| 1974 | Intel 8080 | 8 bits | 2 MHz | Revolucionou os microcomputadores |
| 1974 | Motorola 6800 | 8 bits | 1 MHz | Grande concorrente do 8080 |
| 1975 | MOS Technology 6502 | 8 bits | 1 MHz | Muito barato e extremamente popular |
| 1976 | Zilog Z80 | 8 bits | 2,5–4 MHz | Compatível e superior ao 8080 |
| 1978 | Intel 8086 | 16 bits | 5–10 MHz | Início da arquitetura x86 |
| 1979 | Motorola 68000 | 16/32 bits | 8 MHz | Muito à frente do seu tempo |
Capítulo 8 — Como o COBOL cabia em uma máquina dessas?
O COBOL é uma linguagem conhecida por sua verbosidade.
Um programa simples pode conter:
IDENTIFICATION DIVISION.
PROGRAM-ID. OLA-MUNDO.
PROCEDURE DIVISION.
DISPLAY "NAO ENTRE EM PANICO".
STOP RUN.
À primeira vista, parece estranho executar uma linguagem tão descritiva em um computador tão pequeno.
Entretanto, o código-fonte não permanece necessariamente inteiro na memória durante a execução. O compilador transforma as instruções COBOL em uma representação executável mais compacta.
Algumas implementações também utilizavam bibliotecas de runtime.
Por exemplo, quando o programa executava uma operação complexa, o compilador poderia gerar uma chamada para uma rotina pronta, em vez de repetir toda a implementação em cada programa.
Considere:
MULTIPLY VALOR BY TAXA GIVING RESULTADO.
O compilador poderia gerar instruções nativas ou recorrer a rotinas auxiliares, dependendo dos tipos de dados e da arquitetura.
Operações decimais eram especialmente importantes para sistemas comerciais.
COBOL não existe apenas para somar números. Ele existe para somar números da maneira esperada por contadores, bancos, governos e departamentos financeiros, criaturas conhecidas por considerar um centavo incorreto motivo suficiente para convocar uma reunião de cinco horas.
Capítulo 9 — O primeiro programa de nossa expedição
Vamos imaginar um pequeno programa de cadastro comercial compatível com a filosofia da época.
IDENTIFICATION DIVISION.
PROGRAM-ID. CLIENTE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NOME PIC X(30).
01 WS-SALDO PIC 9(5)V99.
01 WS-SALDO-ED PIC ZZZZ9.99.
PROCEDURE DIVISION.
DISPLAY "NOME DO CLIENTE: ".
ACCEPT WS-NOME.
DISPLAY "SALDO: ".
ACCEPT WS-SALDO.
MOVE WS-SALDO TO WS-SALDO-ED.
DISPLAY "CLIENTE: " WS-NOME.
DISPLAY "SALDO: " WS-SALDO-ED.
STOP RUN.
Mesmo esse programa simples contém vários conceitos fundamentais.
IDENTIFICATION DIVISION
Identifica o programa.
PROGRAM-ID. CLIENTE.
Em ambientes COBOL modernos, o nome do programa pode participar de chamadas, carregamento e organização do executável.
DATA DIVISION
Define os dados utilizados.
01 WS-NOME PIC X(30).
O campo recebe até 30 caracteres.
01 WS-SALDO PIC 9(5)V99.
Representa um valor numérico com cinco dígitos inteiros e duas casas decimais implícitas.
O V não ocupa uma posição física. Ele indica onde o ponto decimal deve ser considerado.
PROCEDURE DIVISION
Contém a lógica.
ACCEPT WS-NOME.
Lê um valor.
DISPLAY "CLIENTE: " WS-NOME.
Apresenta uma informação na tela.
Para um iniciante, esse exemplo ensina a essência do COBOL:
Defina os dados com clareza. Depois descreva o que deve acontecer com eles.
Essa filosofia atravessou gerações de computadores.
Capítulo 10 — Arquivos: onde o COBOL realmente acorda
Exibir “Olá, mundo” é simpático, mas COBOL não conquistou bancos e empresas porque sabia cumprimentar operadores.
Sua força estava no processamento de registros.
Imagine um arquivo sequencial com registros de clientes:
00001ARTHUR DENT 0000012500
00002FORD PREFECT 0000042000
00003ZAPHOD BEEBLEBROX 9999999999
Cada parte ocupa uma posição definida.
Um layout COBOL poderia ser:
01 REGISTRO-CLIENTE.
05 CLIENTE-CODIGO PIC 9(5).
05 CLIENTE-NOME PIC X(30).
05 CLIENTE-SALDO PIC 9(8)V99.
Essa organização é uma das razões pelas quais COBOL continua relevante.
O programa descreve precisamente a estrutura dos dados.
Em um sistema empresarial, isso é vital.
Um registro não pode ser interpretado aproximadamente. O saldo não pode “talvez” ocupar oito posições. O código do cliente não pode assumir uma forma emocionalmente conveniente durante a execução.
O dado precisa ter contrato.
E COBOL adora contratos.
Especialmente contratos com cláusulas, subcláusulas, níveis, redefinições e uma 88 para explicar quando alguma coisa significa “SIM”.
Capítulo 11 — Do código até a execução: passo a passo conceitual
O processo exato dependia do ambiente e da versão instalada, mas a jornada geral seria semelhante a esta.
Passo 1 — Criar o código-fonte
O programador utilizava um editor disponível no sistema ou preparava o arquivo em outro ambiente.
O código precisava obedecer às regras de formato aceitas pelo compilador.
Compiladores antigos podiam ser bastante rigorosos quanto a colunas, margens e disposição das linhas.
Passo 2 — Salvar o programa
O arquivo era gravado em um dispositivo disponível, provavelmente um disquete em configurações mais completas.
O espaço era limitado. Não existia o hábito moderno de manter 37 cópias chamadas:
CLIENTE-FINAL.COB
CLIENTE-FINAL2.COB
CLIENTE-FINAL-AGORA-VAI.COB
CLIENTE-FINAL-REAL.COB
CLIENTE-FINAL-REAL-CORRIGIDO.COB
Pelo menos não com a mesma tranquilidade.
Passo 3 — Executar o compilador
O compilador lia o código e produzia mensagens.
Erros poderiam envolver:
palavras desconhecidas;
divisões ausentes;
níveis de dados inválidos;
períodos mal posicionados;
nomes indefinidos;
sentenças incompatíveis;
problemas de arquivo.
Passo 4 — Corrigir os erros
O programador consultava a listagem e o manual.
Não havia hiperlink.
Não havia botão “corrigir automaticamente”.
Havia reflexão.
E café.
Principalmente café.
Passo 5 — Gerar ou vincular o programa
Dependendo da implementação, poderia existir uma etapa de linkedição ou geração final, reunindo o código produzido com bibliotecas de execução.
Passo 6 — Executar
Finalmente, o programa era iniciado.
Se tudo estivesse correto, produzia o resultado esperado.
Caso contrário, começava a fase conhecida como:
Agora ficou interessante.
Capítulo 12 — COBOL no microcomputador não era COBOL de brinquedo
É fácil olhar para um computador de 8 bits e imaginar que ele servia apenas para experiências domésticas.
Mas pequenas empresas também precisavam de sistemas.
Elas possuíam:
clientes;
fornecedores;
estoques;
contas a receber;
contas a pagar;
notas;
pedidos;
folhas de pagamento;
relatórios;
movimentações.
Essas necessidades eram adequadas ao modelo de processamento do COBOL.
Um microcomputador equipado com discos e software apropriado poderia automatizar atividades que antes exigiriam equipamentos mais caros ou processos manuais.
Eis a verdadeira revolução.
Não era apenas colocar um computador na mesa.
Era permitir que uma organização menor utilizasse conceitos de processamento comercial antes associados a ambientes muito maiores.
O COBOL-80 fazia parte da ponte entre dois mundos:
o mundo dos grandes computadores corporativos;
o mundo emergente da computação pessoal e departamental.
Capítulo 13 — O que mudou e o que permaneceu igual
Compare o Microsoft COBOL-80 com um ambiente COBOL moderno em IBM Z.
Mudaram:
capacidade de memória;
velocidade;
armazenamento;
sistemas operacionais;
ferramentas;
interfaces;
redes;
integração;
depuração;
segurança;
automação;
volume de transações.
Mas vários conceitos permanecem reconhecíveis:
programas;
registros;
arquivos;
campos;
processamento sequencial;
validação;
relatórios;
compilação;
bibliotecas;
módulos;
entrada e saída.
Um programador que compreende bem os fundamentos consegue olhar para um programa antigo e reconhecer sua estrutura.
Ele talvez estranhe as limitações, os comandos específicos e a ausência de recursos modernos. Mas a lógica empresarial continua familiar.
Um cliente ainda possui código.
Um produto ainda possui preço.
Uma conta ainda possui saldo.
E o departamento financeiro ainda deseja o relatório para ontem.
Capítulo 14 — Dicas para o programador COBOL iniciante
1. Aprenda primeiro os dados
Antes de tentar dominar todos os comandos, compreenda:
PIC X;PIC 9;V;S;níveis
01,05,77e88;campos editados;
campos agrupados;
armazenamento decimal e binário.
Em COBOL, compreender os dados vale mais do que decorar cinquenta verbos.
2. Escreva programas pequenos
Comece com:
leitura de nome;
cálculo de valores;
validação;
repetição;
processamento de uma tabela;
leitura de arquivo sequencial.
Não comece tentando reconstruir o sistema financeiro intergaláctico.
Ele já existe e provavelmente está em produção desde 1968.
3. Leia as mensagens do compilador
O compilador costuma fornecer pistas.
Leia:
número da linha;
severidade;
descrição;
mensagens anteriores;
mensagens posteriores.
Um erro no início do programa pode provocar dezenas de erros derivados.
Corrija primeiro a causa mais antiga.
4. Use nomes claros
Prefira:
WS-VALOR-TOTAL
em vez de:
X1
COBOL foi criado para ser legível.
Não transforme o programa em um enigma apenas para provar que você conhece o alfabeto.
5. Entenda o ambiente
Pergunte:
qual compilador?
qual versão?
qual sistema operacional?
qual formato de arquivo?
qual codificação?
qual runtime?
quais extensões são suportadas?
O COBOL não flutua no espaço absoluto. Ele sempre vive em uma plataforma.
6. Respeite programas antigos
Código legado não é automaticamente código ruim.
Muitas vezes ele sobreviveu porque funciona.
Antes de “modernizar”, descubra:
quem usa;
quais regras implementa;
quais arquivos altera;
quais sistemas dependem dele;
quais exceções acumulou;
o que acontece quando falha.
O programa de 1980 pode ser feio.
Mas talvez saiba algo que ninguém mais sabe.
Capítulo 15 — Curiosidades do setor improvável da galáxia
A Microsoft possuía uma identidade muito diferente
No final dos anos 1970, a empresa era amplamente ligada a ferramentas para programadores. O império dos sistemas operacionais para computadores pessoais ainda estava se formando.
O manual COBOL-80 é uma lembrança física dessa fase.
O painel frontal era uma interface de baixo nível real
Não era decoração retrofuturista.
Aquelas luzes e chaves permitiam interagir diretamente com o estado da máquina.
Era uma combinação de console, monitor, depurador e teste de paciência.
64 KB já foram uma quantidade imensa
Muitos sistemas começaram com muito menos memória.
A capacidade máxima teórica não significava que toda máquina estivesse equipada com ela.
Memória custava caro. Adicionar alguns quilobytes poderia representar um investimento sério.
Os disquetes mudaram tudo
Com unidades de disco, tornou-se muito mais prático carregar sistemas operacionais, compiladores e programas.
Sem armazenamento adequado, utilizar uma linguagem como COBOL seria uma aventura consideravelmente mais dolorosa.
O terminal na imagem é virtual
O ambiente moderno está reproduzindo a experiência de uma máquina histórica. Isso permite estudar software antigo sem depender de todo o hardware original.
A emulação é uma espécie de arqueologia executável.
Você não apenas observa o artefato.
Você liga o artefato.
Capítulo 16 — Easter eggs para quem chegou até aqui
Primeiro Easter egg:
O programa de exemplo utilizou nomes como Arthur Dent, Ford Prefect e Zaphod Beeblebrox. Em um sistema comercial real, Zaphod provavelmente seria rejeitado durante o cadastro porque insistiria em possuir duas assinaturas autorizadas e preencheria o campo “quantidade de cabeças” com o valor 2.
Segundo Easter egg:
A frase:
DISPLAY "NAO ENTRE EM PANICO".
é perfeitamente válida como filosofia de programação.
Quando ocorre um erro, o procedimento correto não é entrar em pânico.
É consultar:
a mensagem;
o código de retorno;
a listagem;
o dump;
os dados de entrada;
o manual.
Entrar em pânico consome CPU humana e raramente atualiza o arquivo corretamente.
Terceiro Easter egg:
A toalha é uma ferramenta extremamente útil em um datacenter.
Ela pode servir para:
limpar café;
proteger um manual;
apoiar um teclado;
secar lágrimas após um erro de produção;
demonstrar que você está preparado para viajar pela infraestrutura corporativa.
Apenas não a coloque sobre a ventilação do equipamento.
Mesmo a literatura cósmica possui limites térmicos.
Capítulo 17 — A verdadeira importância histórica do COBOL-80
O valor do Microsoft COBOL-80 não está apenas em sua raridade ou no charme de executar software antigo.
Ele representa um momento de transição.
O computador estava deixando de ser um recurso exclusivo de grandes organizações e começando a alcançar escritórios menores, escolas, desenvolvedores independentes e entusiastas.
Ao disponibilizar uma linguagem comercial nesse ambiente, o COBOL-80 ajudava a transportar conhecimentos empresariais para uma nova escala de hardware.
Ele mostrava que o microcomputador não precisava servir apenas para jogos, experimentos eletrônicos ou demonstrações.
Ele também poderia processar:
faturamento;
estoque;
clientes;
pagamentos;
arquivos;
relatórios.
Essa transformação ajudou a preparar o terreno para a explosão dos computadores pessoais e dos sistemas administrativos das décadas seguintes.
O COBOL estava descendo do grande altar corporativo e entrando pela porta lateral das pequenas empresas.
Provavelmente carregando uma pasta, um relatório de 132 colunas e uma reclamação sobre o formato do arquivo.
Conclusão — O compilador no fim do universo
As três imagens formam uma narrativa completa.
O manual de 1978 mostra a documentação de uma linguagem comercial produzida por uma Microsoft ainda jovem.
A tela do emulador mostra o COBOL-80 executando, com arquivos, módulos e uma versão datada de 1980.
O IMSAI 8080 mostra o tipo de universo físico ao qual esse software pertencia: uma época de processadores de 8 bits, memória escassa, painéis frontais e interação direta com a máquina.
Para o programador COBOL iniciante, essa história ensina algo fundamental:
COBOL não pertence a uma única máquina.
Ele atravessou mainframes, minicomputadores, microcomputadores, servidores, estações, PCs e ambientes modernos.
Sua forma mudou.
Seus compiladores mudaram.
Suas plataformas mudaram.
Mas seu objetivo central permaneceu surpreendentemente estável: representar dados empresariais com clareza e executar regras de negócio de maneira previsível.
Ao olhar para o Microsoft COBOL-80, não estamos vendo apenas uma curiosidade de museu.
Estamos observando um ancestral.
Uma pequena cápsula histórica de quando a Microsoft vendia compiladores, os computadores conversavam por luzes e o programador precisava saber exatamente onde cada byte estava hospedado.
Naquele tempo, a máquina possuía talvez 64 KB.
Hoje, temos sistemas com terabytes, nuvens globais e modelos de inteligência artificial.
Mesmo assim, em algum escritório, neste exato momento, existe um programa moderno consumindo oito gigabytes de memória para produzir um relatório que um COBOL de 1980 tentaria resolver com um disquete, três módulos, uma listagem impressa e uma expressão silenciosa de reprovação.
Portanto, jovem viajante do Bellacosa Mainframe, guarde esta lição:
A tecnologia avança.
As interfaces mudam.
Os computadores ficam menores, depois maiores, depois virtuais, depois “serverless”, embora continuem utilizando servidores em algum lugar.
Mas as contas precisam fechar.
Os registros precisam ser processados.
Os salários precisam ser pagos.
E, enquanto houver uma empresa, um arquivo e alguém perguntando por que o total não bateu, haverá espaço na galáxia para um programador COBOL segurando um manual, uma toalha e uma caneca de café.
Não entre em pânico.
Confira o PIC.
