Como a programação funcionava quando os programadores usavam cartões perfurados?

Eu vi o seguinte: Aprendendo a programar em cartões perfurados

e já vi isso: http://en.wikipedia.org/wiki/Computer_programming_in_the_punched_card_era

mas deixam muito a desejar.

Alguém pode me explicar como os programadores programavam quando usavam cartões perfurados? Especificamente, o sistema de computadores de entrada usado para derivar instruções do próprio cartão perfurado.

Como não sei muito sobre retrocomputadores, qualquer sistema de entrada com o qual você esteja familiarizado seria bom. Respostas mais gerais também são apreciadas.

Em uma palavra, mal.

Pelo menos em qualquer máquina que eu já usei ou ouvi falar, você não alimentou cartões um de cada vez. Havia leitores de cartão automatizados que alimentavam e liam centenas de cartões por minuto (provavelmente em torno de 1000 / minuto, mas não tenho certeza das especificações exatas).

Em um caso típico, você escreveu o código manualmente e o inseriu nos cartões. Cada cartão contém uma linha de código (até 80 colunas). Você pegou o baralho de cartas para ser executado. Dependendo da lista de pendências, de uma hora a mais ou menos um dia depois, você recupera seu deck juntamente com uma impressão dos resultados.

Eu provavelmente deveria acrescentar: como o seu baralho de cartas funcionou como um trabalho, você não apenas enviou o código para o programa em si - teve que escrever algo vagamente semelhante a um arquivo em lote / script de shell com as instruções para compilar e executar seu código. O IBM JCL (por exemplo) permanece fortemente influenciado pelas origens do cartão Hollerith.

Outro ponto secundário: na maioria dos sistemas, lembro-me, você normalmente incluía um número de linha em cada cartão perfurado. Obviamente, você evitou derrubar um baralho, se pudesse, mas quando (não se) um foi derrubado, não foi exatamente a tragédia que muitos imaginam. Ponto interessante: pelo menos os classificadores de cartões que eu vi usavam uma classificação de radix - eles separavam os cartões em 10 posições, com base em um dígito do número da linha, e então "mesclavam" os juntos (coloque todos os cartões em um único bin na ordem) e repita quantas vezes você tiver dígitos nos números das linhas.

As cartas de Hollerith foram extremamente influentes - 80 colunas como limite ainda sobrevivem em um grau quase perturbador. Pelo menos nos mainframes dos Dados de Controle, coisas como o sistema de arquivos também foram fortemente influenciadas. Bem depois que os cartões Hollerith acabaram, os restos deles estavam visíveis no sistema operacional - por exemplo, os arquivos de texto eram frequentemente armazenados como uma série de registros de 80 caracteres, independentemente de poucos / quantos caracteres uma linha realmente continha. Ainda me lembro da minha surpresa com o "atraso" de um sistema como o Unix, onde você tinha que ler todas as linhas anteriores para encontrar a linha N de um arquivo de texto, em vez de apenas poder procurá-lo diretamente.

Você usou o cartão como editor.

• Insira == perfure um novo cartão.
• Mover == pegue o cartão e mova-o para o local certo.
• Excluir == retire o cartão e jogue-o na lixeira
• Copiar - os melhores perfuradores de cartão tinham uma função de cópia que poderia copiar outro cartão, coluna por coluna.
• Substituir um caractere - use a função de cópia, mas digite os caracteres de substituição quando você alcançar o caractere que precisa substituir.
• Excluir um caractere - use a função de cópia, mas segure o cartão copiado para impedi-lo de se mover e pressione espaço para cada caractere que você deseja "excluir"
• Inserir caracteres - use a função de cópia, mas mantenha o cartão original imóvel enquanto digita o novo texto.

Na maioria das vezes, os cartões eram "imutáveis", mas era possível remover os personagens, colando nos buracos com uma fita adesiva fina e opaca.

Você leu em seu programa rodeado pela JCL apropriada e esperou a impressora cuspir os resultados. (Pode demorar horas!)

Muito devagar.

Minha mãe era uma programadora, então eu tinha toneladas desses cartões em casa enquanto crescia. O que eles fariam era codificar o programa nos cartões e, em seguida, alimentar os cartões no leitor de cartões, um por um (semelhante à forma como as urnas funcionam agora). Se você deixasse cair as cartas - você estaria com muitos problemas, porque você só tem o tempo da máquina X alocado para você e teria que organizá-las na ordem certa e reiniciar a alimentação da máquina novamente e tentar fazer a tempo antes que o próximo programador o expulse. Um programa trivial (em nossos padrões atuais) pode exigir centenas, se não milhares, desses cartões e horas de tempo da máquina para carregá-lo e executá-lo.

Muito entediante.

Em alguns aspectos "não muito diferentes", em alguns aspectos "muito diferentes".

Eles escreveram o código fonte, geralmente no papel. Isso foi digitado novamente em cartões perfurados (uma linha de código-fonte por cartão, geralmente com números de linha, para que você pudesse facilmente consertar seu código-fonte quando ele terminasse na ordem errada).

O programa foi então prefixado com cartões contendo instruções sobre como compilar o programa e com o sufixo com instruções sobre como executá-lo e quais arquivos de dados usar (ou fitas para montar etc.).

Este foi então enviado aos operadores, que carregariam os cartões em um leitor de velocidade, executariam o trabalho e retornariam os resultados nas impressões.

Com um ciclo típico de edição / compilação / resultados da ordem de "amanhã", as pessoas tendem a ser mais paranóicas, verificando seu código em busca de erros de sintaxe.

Sem possibilidade de depuração interativa, a única maneira de rastrear a execução seria linhas de depuração impressas durante a execução.

Em alguns lugares, o código estaria na fita perfurada e não nos cartões perfurados.