Programming with Punched Cards and Perforated Tapes

This exercise focuses on the technical mechanisms behind programming with punched cards and perforated tapes. You will explore how data is represented, read, and processed using interactive simulations.

Data Representation on Punched Cards

This simulation demonstrates how a punched card is represented as a binary string. Each character represents a position on the card where '1' indicates a punched hole and '0' indicates no hole.

Waiting for execution...

Note: The binary string simulates the physical layout of punched holes on a card.

Simulated Card Reader

This simulation reads the binary data from a punched card and converts it to an integer value. Modify the cardData variable to simulate different punched card patterns.

Waiting for execution...

Note: This code converts a binary string to its numeric equivalent, simulating the reading process of a card reader.

Processing Data from Punched Cards

This example demonstrates how the data extracted from a punched card is processed and used to control an operation. Modify the binary string below to simulate different card patterns and observe the resulting action.

Waiting for execution...

Note: Here, the interpreted value determines a concrete action, demonstrating a practical use of reading the punched card.

Executing a Complete Program from a Punched Card

In this example, the punched card contains a complete program stored as a binary string. Each 8 bits represent an ASCII character. The program is decoded, displayed, and its execution is simulated by producing a result.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    // Simulated punched card data in binary representing a complete program.
    // The program prints a message: printf("Hello from punched card!\n");
    // Each 8 bits correspond to one ASCII character.
    char cardData[] =
      "01110000"  // p
      "01110010"  // r
      "01101001"  // i
      "01101110"  // n
      "01110100"  // t
      "01100110"  // f
      "00101000"  // (
      "00100010"  // "
      "01001000"  // H
      "01100101"  // e
      "01101100"  // l
      "01101100"  // l
      "01101111"  // o
      "00100000"  //  
      "01100110"  // f
      "01110010"  // r
      "01101111"  // o
      "01101101"  // m
      "00100000"  //  
      "01110000"  // p
      "01110101"  // u
      "01101110"  // n
      "01100011"  // c
      "01101000"  // h
      "01100101"  // e
      "01100100"  // d
      "00100000"  //  
      "01100011"  // c
      "01100001"  // a
      "01110010"  // r
      "01100100"  // d
      "00100001"  // !
      "01011100"  // \
      "01101110"  // n
      "00100010"  // "
      "00101001"  // )
      "00111011"; // ;

// Determine the length of cardData and number of characters (8 bits per character)
    int len = strlen(cardData);
    int numChars = len / 8;
    char program[numChars + 1];
    for (int i = 0; i < numChars; i++) {
        char byteStr[9];
        strncpy(byteStr, cardData + i * 8, 8);
        byteStr[8] = '\0';
        int ascii = (int) strtol(byteStr, NULL, 2);
        program[i] = (char) ascii;
    }
    program[numChars] = '\0';
    
    // Display the program read from the punched card
    printf("Program read from the card:\n%s\n\n", program);
    
    // Execute the program
    printf("In a real scenario, this program would be compiled and executed.\n");
    return 0;
}

Waiting for execution...

Note: This code simulates reading a complete program from a punched card stored as a binary string and decodes it.

Programming with Punched Cards and Perforated Tapes - Learn By Doing

Data Representation on Punched Cards

Simulated Card Reader

Processing Data from Punched Cards

Executing a Complete Program from a Punched Card