Chapter 1 · Lab

Lab: The Dream of Thinking Machines

Run this lab

Edit and run the chapter code

Choose an available implementation, change the code, then run it here or continue in the dedicated Labs workspace.

hotel_checkin_logic.py

"""
Hotel Check-In Logic Gate — a runnable companion to Chapter 1 (The Dream of
Thinking Machines).

This is the Boolean logic engine sketched in Figure 1.6: three true-or-false
facts about a guest combine into a check-in decision. Nothing here is
approximate or probabilistic — Boole's insight was that once a decision can
be reduced to true/false facts and a rule for combining them, a machine can
execute it exactly, every time, with no judgment call left to make.

Run it:   python3 hotel_checkin_logic.py
"""

from dataclasses import dataclass

@dataclass
class GuestState:
    guest_id: str
    paid: bool
    booking_exists: bool
    room_available: bool

def decide_checkin(state: GuestState) -> tuple:
    """Boolean rule: allow check-in only if every hard fact is true."""
    facts = {
        "paid": state.paid,
        "booking_exists": state.booking_exists,
        "room_available": state.room_available,
    }
    allow = all(facts.values())
    failing = [name for name, value in facts.items() if not value]
    return (allow, failing)

GUESTS = [
    GuestState("G-1", paid=True, booking_exists=True, room_available=True),
    GuestState("G-2", paid=False, booking_exists=True, room_available=True),
    GuestState("G-3", paid=True, booking_exists=True, room_available=False),
    GuestState("G-4", paid=True, booking_exists=False, room_available=True),
    GuestState("G-5", paid=False, booking_exists=False, room_available=False),
]

def main():
    print(f"{'GUEST':<8}{'DECISION':<20}{'FAILING FACTS'}")
    print("-" * 55)
    for guest in GUESTS:
        allow, failing = decide_checkin(guest)
        decision = "ALLOW CHECK-IN" if allow else "ESCALATE / DENY"
        reasons = ", ".join(failing) if failing else "none"
        print(f"{guest.guest_id:<8}{decision:<20}{reasons}")

print("\nThe rule never changes. Only the facts do.")
    print("That is the entire idea behind Boolean logic as a computing substrate.")

if __name__ == "__main__":
    main()

Output

Run the code to see output here.

Hands-on Lab

Lab Brief

Title: Exploring the Origins of Artificial Intelligence Difficulty: Beginner Estimated time: 45 minutes Lab ID: VOL1-SEC1-CH1-LAB1

Objective

Build and defend a causal timeline showing how representation, programmability, general-purpose computation, and behavioral evaluation made modern AI possible.

Scenario

You are preparing an engineering briefing for colleagues who know current AI tools but cannot yet explain which earlier ideas those tools depend on.

Learning Objectives

After completing this lab, you should be able to

Identify key milestones in AI history
Explain why AI developed gradually
Connect historical events to modern AI
Translate AI history into architecture, evaluation, and governance lessons

Tasks

Create a timeline covering the following milestones.

Pascal Calculator
Analytical Engine
Ada Lovelace
Universal Turing Machine
Turing Test

For each milestone answer

What happened?
Why was it important?
How did it influence AI?

Transfer Exercise

Choose one domain you already understand.

Examples:

Banking
Healthcare
Retail
Education
Manufacturing
Customer support
Software engineering
Testing
DevOps
Product management

For that domain, identify three repetitive intellectual tasks that people perform today.

For each task, answer:

What information does the person observe?
What decision do they make?
What rule, pattern, or judgment do they use?
What would be risky about automating it?

This exercise connects AI history to a domain whose decisions you can examine directly. The goal is not to design an AI system yet. It is to describe work as observations, representations, decisions, actions, and consequences without assuming that every step should be automated.

Reflection

Write a one-page summary answering:

Which historical breakthrough do you believe had the greatest impact on modern Generative AI, and why?

Your answer should connect the breakthrough to at least one modern engineering concept:

Algorithms
Programmability
Symbolic representation
General-purpose computation
Evaluation of intelligent behavior
Human-machine interaction

Stretch Challenge

Research one AI pioneer not covered in this chapter and prepare a two-minute presentation explaining their contribution.

Architect Track

Create a one-page architecture note titled:

What AI History Teaches Us About Building Production AI Systems

Your note should include:

Historical lesson	Production AI implication
Reasoning must be represented	Define inputs, outputs, concepts, and constraints before choosing tools
Computation must be general-purpose	Prefer reusable platforms and workflows over one-off demos
Intelligent behavior must be evaluated	Create test sets, acceptance criteria, and monitoring before launch
Progress creates new risks	Add governance, review, fallback, and rollback mechanisms

Then apply the note to one modern AI idea:

Internal employee assistant
Customer support bot
Document summarization workflow
Coding assistant
Healthcare triage assistant
Banking policy assistant

Answer:

What human capability is being represented?
What part can be deterministic?
What part needs model intelligence?
What must be evaluated?
What should require human approval?
What could fail in production?
Who owns the risk?

This track is designed for senior engineers, architects, engineering managers, and experienced practitioners entering AI engineering.

Common Mistakes

Mistake	Correction
Treating AI history as trivia	Use history to understand why modern AI systems are built from reasoning, representation, computation, and evaluation.
Jumping directly from Turing to ChatGPT	Identify the intermediate ideas: programmable machines, software, digital computing, and the formal study of AI.
Confusing an invention with its long-term impact	Explain both what was built and what new possibility it introduced.
Treating history as trivia	Map historical ideas to modern work: rules, decisions, feedback, automation, and risk.
Treating architecture as model selection	Architecture includes workflow, data, evaluation, governance, operations, and human accountability.

Verification

Cross-check every date and claimed influence against the chapter references. Another reader must be able to follow each arrow in the timeline and explain why the later milestone depends on the earlier idea.

Success Criteria

You can explain the historical progression of AI without referring to notes, connect at least three milestones to modern AI engineering, describe how one historical idea appears in your own domain, and write a short architecture note that links AI history to production system design.