CS50x 2026 - Lecture 0 - Scratch

Main Ideas, Concepts, and Lessons

• AI is changing programming—but fundamentals still matter

  • AI is everywhere and will increasingly affect how software is built (e.g., finding bugs, adding features, generating responses).
  • However, developers must still understand foundational computer science and how to think so they can remain “in the driver’s seat,” even when using AI as a helper.

• Computer science = problem-solving with structured inputs/outputs

  • A core model: Input → black box (process) → Output.
  • Computational thinking applies CS ideas to real-world problems.
  • Programming languages are tools to express solutions.

• Computers represent everything as patterns of 0s and 1s

  • Under the hood, computers store information as binary (base 2).
  • Key terms explained:
    • Bit: a single binary digit (0 or 1).
    • Transistors: hardware elements that switch states to represent 0/1.
    • Base systems: unary (base 1), decimal (base 10), binary (base 2).
    • Byte: 8 bits.
    • Memory/storage scale: bytes → kilobytes → megabytes → gigabytes → etc. (mentioned as context).

• Encoding text: ASCII and Unicode

  • Letters are represented by standardized integers corresponding to specific bit patterns.
  • ASCII (examples: uppercase A = 65, B = 66, etc.).
  • Example decoding: bit patterns that correspond to 72, 73, 33 map to “HI!”.
  • Lowercase vs uppercase trick:
    • In ASCII, lowercase letters are typically 32 greater than uppercase letters.
    • Thus casing can be changed by flipping one bit in many encodings.
  • Unicode expands beyond ASCII to support many languages and symbols.
  • Emoji are treated as characters encoded in Unicode, but their visual appearance varies by platform (Apple/Google/Telegram).

• Encoding color and images (RGB)

  • Colors are represented numerically using RGB channels:
    • Each of red, green, blue is usually 0–255 (one byte each).
    • Examples:
      • (0,0,0) = black; (255,255,255) = white.
  • Images are composed of many pixels, each with color data.

• Encoding time-based media: video and sound

  • Video: many images shown quickly (≈ 30 frames/second) to create the perception of motion.
  • Audio/music: represent notes using numeric parameters (e.g., frequency/pitch, duration, loudness), assuming the decoder interprets them consistently.

• How computers “know what to do”: algorithms and context

  • Distinguishing “number 65” vs “letter ‘A’” depends on context: the software decides how to interpret the same bit pattern.
  • Core ideas:
    • Algorithms are step-by-step instructions.
    • Code is an implementation of an algorithm in a programming language.

• Algorithm efficiency matters (not just correctness)

  • Example problem: finding a person in a phone book.
  • Three strategies:
    • Linear search: check pages one-by-one → slow, scales like n.
    • Two-at-a-time (imperfect skipping): faster, still linear → scales like roughly n/2 (with caveats).
    • Binary search: repeatedly divide the search space in half → logarithmic growth.
  • Key takeaway: better algorithms use fewer resources and scale better as input grows.

• Pseudo-code and formal structure

  • Pseudo-code: human-readable step-by-step algorithm description.
  • Emphasizes precision and handling corner cases (e.g., “what if the person isn’t in the book?”).

• Core programming constructs introduced

  • Functions (verbs/actions that perform tasks)
  • Conditionals / boolean expressions (yes/no decisions)
  • Loops (repeat actions)
  • These will appear across Scratch, C, Python, etc.

• Abstraction layers: from machine code to Scratch

  • Early programming required raw binary instructions.
  • Compilers translate higher-level languages into lower-level machine representations.
  • This allows programmers to avoid tedious low-level details.

---

Methodology / Instructions Presented (Detailed Bullet Points)

Building a Chatbot in Code (High-Level Workflow)

• Open a coding environment (VS Code).
• Write a Python program (e.g., chat.py).
• Use an AI provider’s API (example shown: OpenAI API) by:
  • Importing the client library.
  • Creating a client object.
• Request a response by calling an API method (conceptually client...responses.create(...)).
• Provide inputs to the API:
  • User prompt (text/question from the human).
  • Model selection (example shown: GPT-5).
  • System prompt (standardized instructions controlling style/constraints such as “limit your answer to one sentence”).
• Run the program via terminal:
  • Execute python chat.py.
• Print the output to see the assistant’s response.

Decoding a Text Message from Bytes Using ASCII (Exercise Flow)

• Treat the received data as 3 bytes.
• Convert each byte’s bit pattern into decimal numbers (example given: 72, 73, 33).
• Use the ASCII table:
  • 72 → H
  • 73 → I
  • 33 → “!”
• Combine into the intended message: “HI!”

Live Team Activity: Spell a Word Using ASCII (Stage Directions)

• Recruit ~8 volunteers to represent bit positions (each person corresponds to a power-of-two place value).
• Volunteers:
  • Stand as “bit placeholders” for a given round.
  • If assigned 0: do nothing (stay down / no raised hand).
  • If assigned 1: raise the single hand.
• As rounds proceed:
  • Determine the resulting decimal value (via placed bits).
  • Map that decimal value to an ASCII character.
• Outcome in this class demo:
  • Round 1: 66 → B
  • Round 2: 79 → O
  • Round 3: 87 → W
  • Final spelled word: “BOW”.

Scratch Programming: “Hello World” and Input–Output Structure

• Use an event block (in Scratch: “when green flag clicked”) to start execution.
• Use a say block to create a visible side effect:
  • Provide text as the block’s argument.
• To prompt the user:
  • Use ask … and wait (returns a value after the user types).
  • Store the returned text in Scratch’s variable (example: answer).
• Compose text dynamically:
  • Use join to combine literals (e.g., "Hello, ") with variables (e.g., answer).
• Control animation timing:
  • Use wait and repeat or forever depending on whether it should run a fixed number of times or continuously.

Scratch “Meow N Times” Abstraction (Build Once, Reuse Forever)

• Start with a loop that:
  • Plays a meow sound.
  • Waits 1 second.
  • Repeats for N times.
• Improve design by:
  • Creating a custom block called meow:
    • Define it in terms of sound playback and waiting.
  • Add an input argument to meow, labeled N.
  • Replace repeated logic in the main program with a single call to meow using N.
• Benefit:
  • Changes to timing/behavior happen in one place (inside meow), not repeated throughout the program.

---

Speaker(s) / Sources Featured

• David Malan (Harvard University; CS50 instructor)
• MIT Media Lab (Scratch’s origin mentioned)
• OpenAI (API used in the chatbot demonstration)
• CS50 course / CS50 staff (teaching assistant referenced as “me”/instructional voice)