برنامه‌نویسی به زبان پایتون |‌ Early Programming

Main ideas / lessons conveyed

1) What “programming” is (and why languages are needed)

• Computers can’t understand human languages directly.
• Programming languages are tools/interfaces that let humans give instructions to computers.
• The need for a language is compared to communicating with animals—you must use a language they can understand.

2) How instructions get from human intent to machine action

Between what humans write and what hardware executes, there are multiple translation layers:

• Humans write code in a human-readable programming language (conceptually “English-like”).
• A compiler (or interpreter) translates that code into machine language.
• Machine language is fundamentally zeros and ones that the CPU understands.

The video emphasizes that this creates intermediaries between human language and hardware-executable instructions.

3) The course structure / learning path (as described)

• This is framed as Lecture 1 about programming.
• It will lead into:
  • A later lecture on programming languages (their history, differences, pros/cons).
  • Then a focus on Python:
    • What’s new about Python, why choose it, what it’s used for, and its advantages/disadvantages.
    • How to set it up.
    • Then learning actual Python programming and coding.

4) Early programming: how “programs” used to exist physically

The lecture “Early Programming” explains how people controlled machines before modern stored-program/software approaches.

Programming-like needs existed before computers

• Example: textile manufacturing.
• Repetitive tasks with patterns required a way to encode sequences of operations.
• Doing this by manual reconfiguration was very hard.

Punch cards

• Punch cards encoded patterns as sequences of holes.
• Different sequences of holes made machines behave differently (e.g., different colors or weaving patterns).
• Historical example: the 1890 U.S. census
  • Punch cards enabled data collection and processing that would otherwise take far longer by hand (described as about 2.5 years instead of manually counting).

Plugboards (switchable wiring)

• Early “programming” used physical wiring layouts (plugboards/panels).
• Wires represented commands; changing the “program” often meant rewiring the machine.
• By the 1920s, plugboards were made swappable to reduce rewiring effort.
• Example workflow described:
  • One plugboard calculates salaries based on days worked.
  • Another plugboard subtracts tax.
  • Another plugboard adds overtime/benefits.
• Programming required deep knowledge of hardware connections.

Why electronic computers changed everything

• Physical/mechanical switching was slow.
• Electronic switching (using transistor-based circuitry) enabled extremely fast switching.
• This made electronic computation practical in the 1940s–1950s and beyond.
• Stored-program concept:
  • Programs (and data) could be stored in memory and accessed quickly by the CPU.
  • Programming shifted from physical rewiring to changing content in memory.

Von Neumann architecture

• The stored-program idea is linked to Von Neumann architecture.
• Mentioned: a first stored-program computer built in 1948 by the University of Manchester (“Baby”).

Punch cards still bridged the gap

• Even with stored-program computers, early systems still needed programs/data loaded into memory.
• Until the 1980s, many computers used punch card readers:
  • Read one card at a time.
  • Write card contents into computer memory.
• Punch cards served as both:
  • Input (programs/data into the computer)
  • Output (results written back out to punch cards)

Punch-card-era limitations

• Large programs required many punch cards.
• Example given:
  • A major U.S. air defense system project used 62,500 punch cards for its main control program (compared to a few megabytes).

Front-panel switch programming (home/early devices)

• Another method mentioned (less emphasized):
  • Toggling switches on a front panel to enter binary instructions directly into memory.
  • Pressing a button to run the program.
• Framed as:
  • Tedious/hard
  • Requiring detailed knowledge of hardware-level instruction formats

5) Overall conclusion: why programming languages exist

• Historically, programming required intimate hardware knowledge and was extremely tedious.
• Programming languages arose as translators:
  • From a more human-like form into a computer-friendly representation.
  • Typically: English-like source → programming language representation → compiler → machine code (0s/1s).
• Python is categorized as a high-level programming language that fits this translator/interfacing idea.
• Next steps in the course:
  • Study programming languages in general (history, advantages/disadvantages).
  • Then learn Python: why it’s useful, setup, and writing Python programs.

---

Methodology / instructions (bullet list)

No step-by-step “how to do X” workflow for learners is given as an actionable method. However, the lecture describes a conceptual pipeline for executing code.

• Conceptual execution pipeline

  • Write instructions in a programming language (human-readable code).
  • Use a compiler/interpreter to convert that code into machine language.
  • Ensure machine language is expressed as 0s and 1s understood by the CPU.
  • The CPU executes instructions using values stored/managed in memory.

• Historical “programming” methods (as described)

  • Textile-style / pattern control
    • Encode desired behavior as an ordered sequence (e.g., thread pattern choices).
  • Punch-card programming
    • Encode the program as a sequence of punched holes/cards.
    • Feed cards into a reader that transfers their contents into computer memory.
  • Plugboard programming
    • Wire/plug cables into a control panel so physical connections correspond to commands.
    • Swap/reconfigure plugboards to change the “program.”
  • Front-panel switch entry
    • Toggle switches to enter binary instruction values into memory locations.
    • Press a button to run the program.

---

Speakers / sources featured

• Narrator / course instructor (explains the historical development and introduces the Python course)
• Crash Course Computer Science host: Carry
  • Explicitly introduced: “Hi, I’m Carry…”