Dinossauros 2 - E como era essa tal de linguagem FORTRAN?

Olá, Dev!

Se você chegou aqui depois de ler meu primeiro artigo na DIO - “Dinossauros 1 - Como eu me tornei um programador (com FORTRAN!) em 1980?”– já sabe da minha saga para aprender programação perfurando cartões. Caso contrário, sugiro voltar lá e ler o artigo, pois este é uma continuação daquele.

Bem, depois de me apaixonar por programação no primeiro semestre do curso de Engenharia Elétrica, eu logo me matriculei na disciplina seguinte sobre programação: Cálculo Numérico!

Ela tratava da aplicação de programação para resolver equações matemáticas (raízes, aproximação, interpolação, erros, etc.), ainda usando FORTRAN e perfurando cartões. Como eu já gostava de matemática, essa parte ficou fácil! E a criação de programas para iterar as operações em busca das soluções (tarefa trabalhosa e sujeita a erros, que a gente já fazia no papel), virou um passatempo. 

O livro usado foi o clássico FORTRAN Monitor, de Tércio Pacitti. (ver figura)

Minha paixão pela programação continuou alta, mas sem o mesmo impacto que a primeira disciplina (Introdução à Ciência da Computação) causou em mim!

Se naquela época já fosse possível programar para visualizar os gráficos das funções, eu teria me empolgado ainda mais!

Mas como um cartão perfurado guardava as informações do código?

Bem, o cartão que a gente usava foi criado pela IBM e tinha 12 linhas e 80 colunas. Ele era usado para codificar 64 caracteres (10 algarismos, 26 letras e 27 caracteres extras) do código EBCDIC (não era do código ASCII), criado pela IBM. O uso de apenas letras maiúsculas no código explica o fato de todo programa em FORTRAN daquela época ser escrito só em maiúsculas!

E como ler os furos de um cartão perfurado?

As três primeiras linhas do cartão, de cima para baixo, eram usadas para diferenciar algarismos e letras (nenhum furo, algarismo; algum furo, letra ou caractere extra). No caso de algarismos, o furo era feito na linha correspondente ao algarismo (linha 1, algarismo 1, e assim por diante). No caso de letras, um furo na primeira linha indicava letra entre A e I, com o furo na linha correspondente à ordem da letra nesta sequência (letra A, furo na linha 1, etc.), já um furo na linha 2, representava os caracteres de J a P, com o furo feito de maneira semelhante ao caso anterior (letra J, furo na linha 1, etc.) e se o furo fosse na terceira linha, significava as letras de Q a Z, com o segundo furo na linha feito de maneira semelhante aos dois casos anteriores((letra Q, furo na linha 1, etc.). Os caracteres seguiam padrões diferentes daqueles dos algarismos e letras.

A figura a seguir mostra um cartão perfurado com uma linha de código, com destaque para os algarismos 1 e 2 (destacados em verde), letras A, B, J e X (em azul) e os caracteres extras =, / e ( (em laranja).  

E como era o código de FORTRAN?

Agora eu vou dar uma ideia de como era programar em FORTRAN em 1980, com uma das primeiras versões da linguagem, procedural, nada estruturado, antes do FORTRAN IV e do FORTRAN 77, a primeira versão estruturada da linguagem.

Como eu expliquei logo acima, por limitação da codificação em cartão perfurado e do conjunto de caracteres na época, você só vai ver exemplos do código nessa época escrito em maiúsculas.

Basicamente, os comandos oferecidos na linguagem eram READ, WRITE, FORMAT, IF (sem o else), GO TO, DO e praticamente só. Nada de IF-ELSE, WHILE, FOR, SWITCH, CASE, etc.

Mesmo sendo uma das primeiras linguagens de alto nível da história, com várias limitações de comandos e dificuldades de fluxo, o FORTRAN inicial já oferecia sub-rotinas e um tipo de dados COMPLEX, para trabalhar com números complexos, além de permitir o uso de cadeias de caracteres (os chamados strings de hoje) e oferecer funções matemáticas prontas para uso (ABS(), SIN(), COS(), etc.)..

No cartão, algumas regras da linguagem tinham que ser seguidas:

· os comandos só podiam ser escritos a partir da coluna 7 do cartão;

· a coluna 6 era reservada para algum caractere que indicava continuação do comando da linha anterior ( a gente costumava usar o *);

· as colunas 2 a 5 eram usadas para um valor numérico (rótulo, label), entre 1 e 9999, que servia de alvo para o desvio de fluxo do programa por um comando GO TO;

· os comandos só poderiam ser escritos até a coluna 72;

· as colunas 73 a 80 eram ignoradas na leitora de cartões;

· um caractere C digitado na coluna 1 indicava a linha como um comentário, não executada;

Os operadores não eram representados pelos caracteres conhecidos hoje, mas por sequências codificadas (ver figura):

Dentre os comandos disponíveis, os mais pitorescos eram aqueles com o GO TO, que enviavam o fluxo do programa para baixo, ou para cima, para dentro de loops, o que tornou esse tipo de programação conhecido como código espaguete (spaghetti code), expressão crítica usada quando um programa não seguia as regras da programação estruturada e abusava de desvios, condicionais ou não, o que torna sua leitura por seres humanos bem difícil.

A expressão código espaguete se refere a programas mal organizados, por isso difíceis de analisar, corrigir e modificar e surgiu do fato de que um fluxograma do programa feito dessa forma provavelmente apresentará várias linhas se entrecruzando, como em um prato de espaguete.

Exemplos de linguagem assim na época eram FORTRAN e BASIC, que veio logo depois e também usava o GO TO.

Exemplos de comandos com GO TO ou IF:

Comando GOTO Incondicional – comando que transferia o fluxo de execução para outro ponto do código, indicado por um número, digitado entre as colunas 2 a 5 do cartão. Ex:

GO TO 120

Comando IF Aritmético – comando que transferia o fluxo de execução para até 3 pontos do código, cada um indicado por um número, digitado entre as colunas 2 a 5 do cartão e dependendo do resultado de uma variável inteira (se menor que zero, igual a zero ou maior que zero, respectivamente ao primeiro label, segundo e terceiro) Ex:

IF ( NUM ) 80, 100, 150

Comando GOTO Condicional – comando semelhante ao IF Aritmético, mas estendia a transferência do fluxo de execução para mais de 3 pontos do código, cada um indicado por um número, digitado entre as colunas 2 a 5 do cartão e dependendo do resultado de uma variável inteira (se igual a 1, vai para o primeiro desvio, igual a 2, segundo desvio, etc.). Ex:

GO TO (10, 20, 25, 80, 100) NUM

Sim, mas como era um programa completo escrito em FORTRAN?

Aqui eu escrevi dois programas clássicos, usando FORTRAN antigo (FORTRAN II), para mostrar a dificuldade de se escrever código apenas com os comandos disponíveis na época, bem como dar exemplos de código espaguete.

1 - Programa para calcular a média de números inteiros lidos.

2 - Programa para determinar as raízes de uma equação de segundo grau.

Erros de gravação: A minha paixão pela programação me pregou uma peça! A matrícula em disciplinas na UFPB era feita varrendo-se a lista de disciplinas pretendidas por cada aluno, de todos os cursos, começando pela primeira opção de todos, preenchendo todas as vagas disponíveis oferecidas, depois varrendo-se a segunda opção da lista de todos e assim por diante, até que todas as vagas fossem preenchidas. Pois bem, com medo de eu não conseguir a vaga para a minha desejada disciplina Cálculo Numérico para os alunos mais antigos, imaginando que ela seria muito concorrida, eu a coloquei como minha primeira opção. Em segundo coloquei Física 2, em terceiro Cálculo 2. No curso de Engenharia Elétrica, existe um sequência de pré-requisitos que deve sder seguido até a metade da fase profissional do curso:

( Física 1 -> Física 2 -> Física 3 – Física 4 -> Circuitos Elétricos 1 -> Eletrônica )

Quem for reprovado em alguma dessas disciplinas, fica desgarrado dos alunos da mesma turma que entrou no mesmo período (semestre) e que vão sendo aprovados nelas.

E foi o que aconteceu comigo, não por reprovação, mas porque faltou vaga para eu me matricular na disciplina Física 2 (a minha segunda opção na lista de disciplinas pretendidas, ao invés dos outros colegas, que a colocaram em primeiro). Tentei falar com o Coordenador do curso e expliquei que o índice de abandono das disciplinas de Física era muito alto e em poucos dias, abriria alguma vaga para eu poder cursar sem ser excedente na turma, mas não teve jeito.

Resultado: eu me desgarrei dos colegas da minha turma e, mesmo sem ser reprovado em nenhuma disciplina no curso, só consegui alcança-los na metade do profissional. Cursei todas as disciplinas de Física com a turma que entrou no segundo semestre do ano que eu ingressei na Universidade ao invés da turma que entrou comigo no primeiro semestre.

E depois de Cálculo Numérico?

Aprovado na disciplina, com média 8.5, não tinha mais nenhuma disciplina ligada à programação no curso. Concluída a graduação, entrei logo na Pós-graduação e, no primeiro semestre, foi oferecida uma disciplina de Métodos Numéricos, ainda usando FORTRAN, mas sem os cartões perfurados. E é claro que eu fui cursá-la!!

Mas aí já é outra história!!! Assunto para outro artigo.

Obrigado por ler até aqui. Até a próxima!!