From Silicon to Chips

Big idea: Every program you have ever run — every game, every chat, every AI model — finally comes down to billions of tiny switches turning on and off. Those switches are called transistors, and the smart part is how we wire them together to make decisions.

A single transistor is not clever. It is just an electrically controlled switch: a signal comes in, and it either lets current through (1, on) or it does not (0, off). On its own that is about as exciting as a light switch. The trick is combining switches into logic gates — small circuits that follow a rule. An AND gate turns on only when both of its inputs are on. An OR gate turns on when either input is on. A NOT gate flips its input: on becomes off, off becomes on. Those three rules — AND, OR, NOT — are exactly the Boolean operators you use when you write a conditional in code, like if (badgeValid AND doorClosed). The hardware and the program are speaking the same language.

Stack enough gates together and you can build anything a computer does: adding numbers, storing a value, comparing two things, deciding what to draw next. A modern chip is a slab of silicon with billions of these gates etched into it — the deciding-machine made real and made tiny. When you understand a gate, you understand, in miniature, the engine underneath every device you own.

That understanding is also practical. When a device misbehaves, knowing the layers — hardware (the physical chips and parts), software (the instructions), and the connection between them — is what lets you troubleshoot instead of guess. And once you can read a device as a stack of decisions made for some user, you can start asking the real engineer's question: how would I redesign this so it works better for the people who actually use it?

Essential question: How do billions of tiny on/off switches add up to a machine that can decide?

Teacher Guide — From Silicon to Chips

Sessions: 2 × 45 min (see grade-banded pacing) · Format: unplugged-first — students build logic gates with their bodies and paper; an optional circuit simulator is listed but never required. No student logins, no student data collected.

At a glance

• Big idea: A transistor is just a switch (on = 1, off = 0). Wire switches into logic gates that follow the rules AND, OR, NOT — the same Boolean operators used in code — and you can build a machine that decides. A chip is billions of those gates etched in silicon. Knowing the hardware / software / connection layers lets you troubleshoot, and reading a device as decisions-made-for-a-user lets you redesign it.
• Essential question: How do billions of tiny on/off switches add up to a machine that can decide?
• You do not need a hardware background to teach this. Every move is scripted below; every material is a common classroom item or a printable in this unit's Printable Materials. No soldering, no breadboards, no electricity required.

Learning targets (kid language)

1. I can predict and explain the output of an AND, OR, or NOT gate, and connect each one to the Boolean operator of the same name in code.
2. I can build a simple decision by combining gates (e.g., "unlock only if the badge is valid AND the door is closed") and write it as an if-statement.
3. I can name the hardware, software, and connection layers of a device and diagnose which layer a problem is in.
4. I can recommend a design improvement to a device for a specific user's needs and say why it helps.

Standards (what each target proves)

Target	VA CS SOL (2024)	Plain gloss
Predict gate output; tie AND/OR/NOT to code	6.AP.2	plan/implement algorithms with conditional control structures (Boolean operators)
Combine gates into a decision as an if-statement	6.AP.2	conditionals using and/or/not in a block- or text-based tool
Diagnose hardware vs. software vs. connection	6.CSY.2	identify & explain hardware/software/connectivity problems and troubleshooting
Recommend a redesign for a user's needs	8.CSY.1	recommend & design improvements to computing devices for various users

VDOE AI Guidance: Responsive to Evolving Tech — students see that today's AI runs on the same on/off logic, so the foundation outlives any one product.

Honest standards note: the 2024 6-8 SOL has no transistor-level standard. We use transistors and gates as the concrete story for 6.AP.2's Boolean operators. The assessed claim is the Boolean logic and the if-statement, not the physics of silicon. Teach the hardware as motivation; grade the logic.

Materials (all common, all reusable)

• The gate-rule cards, truth-table build sheets, device-layer sort cards, and the "Redesign for a user" planner — print/cut from this unit's Printable Materials (one set per group of 3-4).
• Sticky notes or index cards labeled 0 and 1 (two per student) for the human-gate build.
• Chart paper for the class "Gate Wall" (AND / OR / NOT with their truth tables).
• Optional, not required: one shared device with a free browser logic-gate simulator (e.g., a logic-circuit sandbox) for the extension. The full lesson works with zero devices.

Pacing by grade

	Active time	Adjust
6	2 × 40 min	Build AND/OR/NOT only; write the if-statement in plain English or blocks
7	2 × 45 min	Add a 2-gate combo ("AND then NOT"); write the if-statement in real syntax
8	2 × 45-50 min	Add the redesign task in depth (8.CSY.1); require a user-needs justification

If you only have 20 minutes: do the Hook + the human-AND-gate build + write one if-statement on the board. That alone meets the core of 6.AP.2.

---

Lesson plan

1. Hook — "You are a transistor" (5-6 min)

Give every student a 0 card and a 1 card. Say: "A transistor is the simplest machine in the universe — it's a switch. Current comes in; it either passes it through (that's a 1) or it blocks it (that's a 0). That's the whole job. Not smart. Boring, even." Have students flip a card up on your call. Then: "One switch is boring. Here's the magic trick: I can take two of you, give you a rule for when to turn on together, and suddenly you can make a decision. That rule is called a logic gate — and you already know its name from code: AND, OR, NOT."

Why this works: it puts "on/off" in students' hands before the abstraction, and names the bridge to code (Boolean operators) in the first two minutes so the whole lesson has a payoff.

2. I do — the three gates, out loud (8-10 min)

Stand two volunteers at the front as inputs A and B. Hold up the AND gate-rule card and think aloud: "AND means the output is 1 only when A is 1 AND B is 1. Both. If either one is 0, the answer is 0." Walk all four input combinations and fill the AND truth table on the Gate Wall. Repeat for OR ("1 if either is 1") and NOT ("one input, and it flips it — that's the only gate with a single input"). Then make the bridge explicit: write if (raining AND coldOutside) { wearCoat } and say "the gate and the if-statement are the same idea — this is 6.AP.2."

This is the core 6.AP.2 beat: AND/OR/NOT as Boolean operators in a conditional. Keep the truth tables visible all lesson — students will reference them constantly.

3. We do — build a decision together (8-10 min)

Pose a real problem: "A school door should unlock only if the badge is valid AND the door is currently closed (so it doesn't fling open on someone)." As a class, decide which gate(s) you need, fill the build sheet's truth table, and co-write the if-statement: if (badgeValid AND doorClosed) { unlock() }. Then twist it: "Now make it unlock if the badge is valid OR a teacher override is pressed." Students swap AND→OR and see the truth table change. Model the move from gate → truth table → if-statement every time.

4. You do — group builds + the troubleshooting turn (12-14 min)

Groups of 3-4 take a scenario card (e.g., "porch light: on if it's dark AND someone is near," "alarm: on if (a door is open OR a window is open) AND NOT the system is disarmed" — mind the parentheses). Each group: (a) picks the gates, (b) completes the truth-table build sheet, (c) writes the if-statement. Circulate and ask each group to prove one row of their table.

Then hand each group a device-layer troubleshooting card: a device isn't working ("the smart speaker won't respond"). Groups sort the possible cause into hardware (mic is broken), software (the app froze), or connection (Wi-Fi is down) and name one diagnostic step for each layer. (This is the 6.CSY.2 beat — keep it tight: name the layer, name a test.)

5. Closure — "Redesign it for a user" (6-8 min)

Each group takes one device from the lesson and one specific user from the Redesign planner (a person who is blind; someone with limited hand mobility; a grandparent new to the device; a student in a noisy house). They write one improvement and why it helps that user: "Add a spoken confirmation so a blind user knows the door unlocked." Share two or three aloud. (This is the 8.CSY.1 beat — the claim is "improvement justified by a named user's needs," not a finished product.)

---

Common misconceptions

• "A transistor is smart / it thinks." → No. A single transistor is just a switch. All the intelligence is in how switches are wired together (the gates and the logic).
• "Logic gates are old hardware stuff; code is different." → They are the same idea. AND/OR/ NOT in a circuit and and/or/not in an if are identical Boolean operators — that's the whole point of 6.AP.2 here.
• "OR means one or the other but not both." → In computing, OR is inclusive: it's 1 if either or both inputs are 1. (The "one but not both" version is XOR — mention only if asked.)
• "If a device breaks, it's the hardware." → Often it's software (a frozen app) or the connection (no Wi-Fi). Good troubleshooting tests each layer instead of assuming.
• "A better device just means more features." → A real improvement is tied to a specific user's need; more features can make a device worse for some users.

Background (teacher notes)

A transistor is a voltage-controlled switch; modern chips pack tens of billions onto a fingernail of silicon. You don't need the physics — what scales forward is the abstraction ladder: switch → gate → Boolean logic → conditional → program. The reason this unit opens a machine learning band is that everything later still runs on this floor: a neural network's matrix multiply, an LLM's attention, an AI agent's tool call — all of it compiles down to AND/OR/NOT on silicon. Students who own "it's all switches and logic" are inoculated against the magical thinking that makes AI feel unknowable. The troubleshooting (6.CSY.2) and redesign (8.CSY.1) beats turn passive users into people who can reason about and improve the systems around them — the disposition the VDOE "Responsive to Evolving Tech" principle is after.

Safety & privacy note

This unit is unplugged-first and collects no student data. If you use the optional simulator, choose a no-login browser sandbox and keep it on a shared device. The school-door and alarm scenarios are hypothetical models for practicing logic — do not ask students to describe real security systems, badges, or access codes from their homes or this building.

Spiral — where this goes next

• Unit 2 (What Machine Learning Really Is): the decisions stop being hand-wired and start being learned from data — but they still run on these gates.
• Unit 3 (Neural Networks by Hand): a neuron is a weighted decision; layers of them are layers of logic, built up from this same floor.
• 9-12: switch → gate → Boolean logic → the matrix math under deep networks and the tool-using agent. The on/off floor never goes away; everything above it gets deeper.

Printable Materials — From Silicon to Chips

How to use: Print one set per group of 3-4 on cardstock if you can; cut along the lines and reuse all year. Nothing here needs a device. Grade 6: use Materials A, B (AND/OR/NOT), C, D. Grade 7: add the two-gate row on Material B. Grade 8: spend the most time on Material D (redesign). The Teacher answer key at the end is for you — do not print it for students.

Material A — Gate-rule cards (cut apart)

AND gate — &<br/>Output is 1 only if both inputs are 1.	OR gate — ≥1<br/>Output is 1 if either or both inputs are 1.
NOT gate — ¬<br/>One input. It flips it: 1→0, 0→1.	In code<br/>if (A AND B) · if (A OR B) · if (NOT A)

Material B — Truth-table build sheets (one per group)

AND

A	B	Output (A AND B)
0	0
0	1
1	0
1	1

OR

A	B	Output (A OR B)
0	0
0	1
1	0
1	1

NOT

A	Output (NOT A)
0
1

Two-gate combo (Grade 7-8): (A OR B) AND (NOT C)

A	B	C	(A OR B)	NOT C	Output
1	0	0
0	0	1
1	1	1
0	1	0

Write the decision as code: if ( ________ ) { ________ }

Material C — Device-layer troubleshooting cards (cut apart)

Sort each problem into Hardware, Software, or Connection, then name one test.

🔇 Smart speaker won't respond<br/>to "what's the weather?"	🌀 App is frozen<br/>the screen won't scroll or tap
📶 Video keeps buffering<br/>on the school tablet	🔋 Laptop won't turn on at all<br/>even when plugged in
🖨️ Printer "offline"<br/>but it has paper and power	🎮 Controller won't pair<br/>to the console

Sort mat (one per group):

🧱 Hardware	💾 Software	🔌 Connection
physical part	the instructions	the link between them

Material D — "Redesign for a user" planner (one per student or pair)

Pick one device from the lesson and one user below. Write an improvement and why it helps.

User (pick one)	Their need
🦯 A person who is blind	Can't rely on a screen; needs sound or touch feedback
✋ Someone with limited hand strength	Can't press hard or do fine taps
👂 A person who is deaf	Can't rely on beeps or spoken alerts
👵 A grandparent new to the device	Needs simple, clear steps and big controls
🏠 A student in a noisy or shared home	Can't rely on quiet or on a private screen

My device: ________ My user: ________ My improvement: ________________________ Why it helps this user: ________________________

---

Teacher answer key (do not print for students)

Material B — truth tables

• AND: 0,0→0 · 0,1→0 · 1,0→0 · 1,1→1
• OR: 0,0→0 · 0,1→1 · 1,0→1 · 1,1→1 (inclusive — 1 if either or both)
• NOT: 0→1 · 1→0
• Two-gate (A OR B) AND (NOT C): (1,0,0)→(1)(1)→1 · (0,0,1)→(0)(0)→0 · (1,1,1)→(1)(0)→0 · (0,1,0)→(1)(1)→1

Material C — layer sort + a sample test

• 🔇 Smart speaker won't respond → could be any layer; test the connection first (is Wi-Fi up?), then software (restart the app), then hardware (is the mic muted/broken?).
• 🌀 App frozen → Software — force-quit and reopen the app.
• 📶 Video buffering → Connection — check signal strength / move closer to the router.
• 🔋 Laptop won't power on → Hardware — try a different outlet/charger, check the battery.
• 🖨️ Printer "offline" with power & paper → Connection — re-pair to Wi-Fi / reconnect the cable.
• 🎮 Controller won't pair → Connection — re-pair; if it still fails, hardware (battery).
• Accept reasoned disagreement: many real faults span layers. Full credit = correct layer and a real diagnostic test, not the "right" single word.

Material D — redesign

• A strong answer names a specific user need and an improvement that directly serves it (e.g., blind user → spoken/haptic confirmation; limited hand strength → voice or auto-trigger; deaf user → visual/vibration alert). Reject "just make it better / add more features."

Vocabulary — From Silicon to Chips

Six precise words. Post them on the word wall with their truth-table picture where it helps; they spiral forward — model and training data (Unit 2), neuron and weight (Unit 3) all sit on top of this on/off floor.

Word	Kid-friendly meaning	Say it in a sentence
transistor	A tiny electronic switch: it's on (1) or off (0).	"A chip has billions of transistors turning on and off."
logic gate	A small circuit that follows a rule like AND, OR, NOT.	"An AND logic gate turns on only when both inputs are on."
Boolean operator	The words and / or / not that combine true/false to make a decision.	"I used the Boolean operator AND in my if-statement."
conditional (if-statement)	Code that does something only if a condition is true.	"The conditional unlocks the door only if the badge is valid AND it's closed."
hardware vs. software	Hardware is the physical parts; software is the instructions.	"A frozen app is a software problem, not hardware."
troubleshoot	To figure out which layer a problem is in and test it.	"I troubleshoot by checking the Wi-Fi connection first."

Anchor pair

Keep returning to the engine of the whole unit: switch → gate → decision. A transistor is a switch; a gate is a rule over switches; a conditional is that same rule in code. Every later band just stacks more on this pair — the floor never changes.

Spiral note (for teachers)

We name Boolean operator explicitly (not just "AND/OR/NOT") because that's the exact language of 6.AP.2, and it returns in every programming standard above this band. Logic gate is the concrete hook for it now; in 9-12 the same Boolean logic underpins how networks of "neurons" combine signals. Teaching the precise word now prevents re-teaching later — the meaning deepens, it never gets undone. Keep inclusive OR straight (1 if either or both) so students don't carry a wrong model upward.

Differentiation & Access — From Silicon to Chips

Designed against Universal Design for Learning: multiple means of representation, expression, and engagement. The core build is hands-on and reading-light by default; abstraction is always anchored to a physical move (cards up = 1, cards down = 0).

Support (emerging learners & IEP)

• Start with one gate at a time (AND only) and a pre-filled truth table where students just check whether each row is right before building their own.
• Offer a sentence frame for the if-statement: if ( ____ AND ____ ) { ____ }, with a word bank of the scenario's terms.
• Let students prove a gate by physically arranging the 0/1 cards instead of writing — the human-gate build is a complete demonstration of 6.AP.2 with no writing required.
• For troubleshooting, give a 3-column sort mat (Hardware / Software / Connection) and have students place pre-written cause cards rather than generating causes cold.

English learners

• Display each gate as symbol + word + truth table together (AND, OR, NOT), and pair the English operator with its cognate where one exists (Spanish "y / o / no" for and/or/not).
• Allow students to explain their if-statement in the home language first, then echo the English operator back. Accept the logic even when the English is still forming.
• Use a consistent gesture set with the whole class: AND = two fists pressed together (need both), OR = open hands (either works), NOT = a flip of the wrist. A motor anchor for abstract logic helps everyone.

Extension (classroom-anchored — no home tech needed)

• Have students build a two-gate combination from this lesson's scenarios (e.g., "alarm on if (a door OR window is open) AND NOT disarmed" — the parentheses matter) and verify the full truth table.
• Challenge: pick a device in this classroom or school (the smartboard, a charging cart, the PA system), name its hardware / software / connection layers, and propose one redesign for a specific user (links forward to 8.CSY.1).
• If a shared device is available, let the group rebuild their gate in the optional simulator and check that the simulator's output matches their hand-built truth table — never required for mastery, always optional.

Access & accommodations

• Fine-motor: offer large floor cards or a digital build sheet; the 0/1 cards can be replaced by standing up (1) / sitting down (0) so no small manipulation is needed.
• Vision / color: label gates and inputs with the word + symbol (AND, OR, NOT; 0, 1), never color alone; provide a large-print or screen-reader-friendly truth table; read each row aloud.
• Hearing: pair every spoken rule with the written gate card and the gesture; face students when speaking; the entire truth-table build is visual, so no step depends on hearing.
• Non-speaking / AAC: accept the if-statement and the layer-sort by placement, pointing, typing, or an AAC device; a student can fully show mastery by building the table and arranging cards, with no speech required.
• Sensory / attention: chunk the lesson into one gate per short burst; offer a quiet "show-me-the-table" option instead of a whole-group share-out; keep the Gate Wall posted as an always-available reference so nothing relies on holding it in memory.

From Silicon to Chips — Assessment

This is performance-based: students prove they understand the logic by building a decision and diagnosing a device, not by memorizing definitions. Use the look-fors during the Unit 1 group builds, the troubleshooting turn, and the redesign closure. Every look-for names the standard it evidences, so the alignment is verifiable at a glance.

Learning targets

A student who has met this unit can:

1. Predict the output of an AND, OR, or NOT gate for any inputs, and name the matching Boolean operator used in code. (6.AP.2)
2. Combine gates into a decision and write it as an if-statement using and/or/not. (6.AP.2)
3. Diagnose whether a device problem is in the hardware, software, or connection layer and name a test for it. (6.CSY.2)
4. Recommend a design improvement to a device for a specific user's needs and justify it. (8.CSY.1)

Observational checklist (mark one per student)

Look-for	Standard	Not yet	Developing	Got it
Completes a correct truth table for AND, OR, or NOT	6.AP.2	○	○	○
Names the Boolean operator (and/or/not) that matches the gate	6.AP.2	○	○	○
Writes a working if-statement that uses a Boolean operator to make a decision	6.AP.2	○	○	○
Sorts a device problem into hardware / software / connection and names a diagnostic test	6.CSY.2	○	○	○
Recommends a device improvement tied to a named user's need and says why it helps	8.CSY.1	○	○	○

Performance task — "Build the decision, fix the device" (8-10 min, small group or 1:1)

Part A — Boolean logic (6.AP.2). Give this scenario: "A bike light should turn on only when it is dark AND the bike is moving."

• Student fills the truth table (4 rows: dark/not × moving/not) and states which gate fits.
• Student writes the if-statement: if (dark AND moving) { lightOn() }.
• Twist: "Now make it also turn on if the rider presses a button — even in daylight." Student edits to use OR: if ((dark AND moving) OR buttonPressed) { lightOn() }.

Part B — Troubleshooting (6.CSY.2). "A classmate says the bike light 'just won't come on.'" Student names one possible cause in each layer — hardware (dead battery/burned-out LED), software (the sensor's program has a bug), connection (the sensor cable is unplugged) — and one test to check a layer.

Part C — Redesign (8.CSY.1). "Improve this bike light for a rider who is deaf and a rider who has limited hand strength." Student gives one improvement per user with a reason (e.g., for the deaf rider, "a visual or vibrating handlebar indicator so they can see or feel that the light is on without relying on an audible click"; for the low-strength rider, "auto-on from a light/motion sensor so they needn't press a stiff switch").

Scoring

• Meets (6.AP.2): truth table correct for ≥1 gate and a valid if-statement using a Boolean operator.
• Meets (6.CSY.2): correctly assigns ≥2 causes to the right layer and names a real test.
• Meets (8.CSY.1): at least one improvement clearly justified by a named user's need.
• Approaching: logic mostly correct but if-statement or layer assignment has one error; redesign is a generic "make it better" without a user reason.
• Reteach: can't fill a truth table or treats AND/OR as interchangeable → revisit the human-gate Hook and the Gate Wall.

Exit ticket (whole class, ~3 min)

On a sticky note, each student answers both:

1. Fill the blank row: "An AND gate outputs 1 only when ___ and ___ are both 1." Then: "if (badgeValid ___ doorClosed) — which operator unlocks the door only when both are true?" (Answer: AND.) (6.AP.2)
2. "My tablet won't load a video. Name one thing to check in the connection layer." (Any reasonable answer: Wi-Fi on? signal? airplane mode off?) (6.CSY.2)

Scan for two error patterns: treating OR as exclusive, and blaming "the hardware" for every problem. Re-teach the relevant beat if more than a few miss it.

Evidence to keep: one photo of each group's completed truth-table build sheet plus its if-statement documents targets 1 and 2 at once; the redesign planner is the artifact for target 4.

Family Letter — From Silicon to Chips

Dear family,

This unit started our middle-school strand on how computers — and the AI everyone is talking about — actually work, from the ground up. Your student learned that every device runs on billions of tiny on/off switches called transistors, wired into logic gates that follow the rules AND, OR, NOT. Those are the same Boolean operators used in real code, so your student wrote simple "if this and that, then do this" decisions — and practiced troubleshooting a device by figuring out whether a problem is in the hardware, the software, or the connection.

Try this together — no device needed: play a quick round of "AND / OR / NOT" at home. Make a house rule and say which operator it uses. "You can have dessert if you finished dinner AND your homework" is an AND rule (both must be true). "You can take the bus OR I can drive you" is an OR rule (either works). "You can use a screen if it is NOT after 9pm" is a NOT rule — it flips the "after 9pm" condition (allowed only when that is not true). Then troubleshoot something for real: next time a remote, a phone, or the TV acts up, ask your student to guess out loud — is this the hardware, the software, or the connection? — before anyone fixes it. No working device handy? The dinner-table rules game is the whole activity on its own. You can do this with a trusted adult, including your student's teacher, if home isn't the place for it.

One habit to keep: when a device misbehaves, name the layer before you guess the fix — hardware, software, or connection. It turns frustration into a quick diagnosis.

Thank you for learning alongside us.

---

This letter is available in other languages — just ask your student's teacher. Esta carta está disponible en otros idiomas — pregunte al maestro de su hijo/a.

Silicon Logic: A Truth-Table Worksheet

The math underneath the hardware. A logic gate is a tiny machine that takes two inputs — each either 1 (true) or 0 (false) — and produces exactly one output. A truth table lists every possible combination of inputs and the output each one produces. It is the same kind of complete-and-exhaustive table you build in math class when you list every case of a problem.

Fill in the truth tables. For each gate, work out the output for all four input combinations.

AND gate — output is 1 only when both inputs are 1.

A	B	A AND B
0	0	?
0	1	?
1	0	?
1	1	?

OR gate — output is 1 when either input is 1.

A	B	A OR B
0	0	?
0	1	?
1	0	?
1	1	?

NOT gate — flips a single input.

A	NOT A
0	?
1	?

Now build a two-gate circuit. A door alarm should turn on only when the door is open AND the alarm is armed, but it should never go off if a "snooze" switch is on. Using AND, OR, and NOT, write the rule as a single logic expression (for example: (door AND armed) AND (NOT snooze)), then build the truth table for all three inputs — it will have eight rows.

Essential question: How do billions of tiny on/off switches add up to a machine that can decide?

Talk about it: Every conditional you have ever written in code — if this and that — is one of these gates in disguise, and every gate is physically etched, by the billions, into a sliver of silicon the size of a fingernail.