An elite tech academy, taught by a former NASA engineer.

We start without code. On the whiteboard, we work through what it means for a machine to "decide" something — using a paper-and-pencil exercise where you trace a decision tree from input ("is it raining? · is it cold?") to output ("bring an umbrella, wear a coat"). By 11 AM you can name the three pieces of any learning system — inputs, weights, output — and explain a perceptron with nothing but addition and multiplication. We also cover what an algorithm is, what training data is, and what the word "model" really means in this context (hint: it's not metaphorical).

What does it actually mean for a machine to "decide" something? We figure it out without touching a computer — drawing decision trees on the whiteboard ("is it raining? + cold? → wear a coat"). By 11 AM you can explain how a brain-cell-shaped thing called a perceptron makes decisions using just adding and multiplying. You can probably teach this to your parents over dinner.

Open your own Google Colab notebook — yours forever, no install, runs free in Google's cloud. Your first Python program is a greeting bot: it asks for your name, your age, and what you're scared of, then composes a personalized response. You learn variables, strings, input/output, and your first if-statement. The bot you build on Day 1 grows every day — by Friday it can hold a multi-turn conversation that remembers what you've told it.

Open Google Colab on your laptop — it's free, lives in the cloud, no install. Write your first Python program: a greeting bot that asks your name, your age, what scares you, then writes back. You learn variables, strings, and if-statements. The bot keeps growing all week — by Friday it can hold a real conversation that remembers everything you told it.

Draw a single neuron on the whiteboard with the class. Inputs come in on the left, each multiplied by a weight you can adjust; they get summed; the sum goes through an activation function; out pops a decision. We hand-trace it through three example problems: a NAND gate, a thermostat ("turn the heat on when it's below 65"), and a junk-mail filter ("flag this email if it contains three or more of these red-flag words"). By lunch you can explain weights vs. bias to a friend.

Draw a single neuron on the whiteboard with the class. Inputs come in on the left, get multiplied by weights you control, get added together, run through a decision rule, out pops an answer. We trace it through a junk-mail filter, a thermostat, and a NAND gate (sounds scary, isn't). By lunch you can explain how a neuron actually works to anyone who'll listen.

Build a single neuron in pure Python — no libraries, no PyTorch, just NumPy for the math. You'll write the forward pass (input → weighted sum → activation), the loss function (how wrong was the guess?), and the update rule (nudge the weights to be less wrong). Then train it on the XOR problem and watch the weights converge over 1,000 iterations. Plot the loss curve. Look at the trained weights. You just made a thing learn.

Build a single neuron in pure Python. No libraries — you write everything yourself. Train it on the XOR problem and watch the weights bounce around for a thousand tries until they figure it out. Plot how wrong it was over time and watch the line drop. You just made a thing learn. That's wild.

One neuron can solve simple problems; many neurons stacked into layers can solve almost anything. We talk about why deep networks work, what an activation function does (and what happens when you pick the wrong one), and how backpropagation lets the network fix its own mistakes — without the calculus terror. Demo on the projector: watch a network learn to separate two interleaving spirals over the course of 30 seconds, the decision boundary visibly bending into the right shape.

One neuron is cute. Many neurons stacked in layers can solve almost anything. We talk about why deep networks actually work, what an activation function does, and how a network fixes its own mistakes — no calculus terror. Demo on the projector: watch a network learn to untangle two spirals in 30 seconds, the boundary visibly bending into the right shape.

Build a real multi-layer network and train it on MNIST — the classic 60,000-image handwritten-digit dataset that every AI engineer trained on first. Target: 97% accuracy on the test set in under 10 epochs. You'll write the training loop yourself, watch the loss drop, and then debug the cases where it gets it wrong (turns out the network thinks a sloppy 4 is a 9 — and you'll learn why).

Build a real multi-layer network and train it on MNIST — 60,000 handwritten digits, the dataset every AI engineer trained on first. Goal: 97% accuracy. You write the training loop yourself, watch it get smarter, then debug the weird mistakes. The network thinks a sloppy 4 is a 9 — and you'll figure out exactly why.

Day 3's CNN is how everyone has done image recognition for the last 30 years: stack layers, train with backprop, hope the statistics work out. Marcella — Bee's own AI architecture — does it differently: instead of learning statistical weights, every input becomes a point in a geometric space, and decisions come from where those points cluster. Today you build Marcellette, a kid-sized version of Marcella, and run it on the same MNIST digits you classified yesterday. We work through the intuition with chalk first: each digit is a point in 3D space, similar digits cluster together, prediction is just "which cluster is this new point closest to?" No softmax, no backprop, no statistical assumption. You can see the AI thinking by looking at where the points land.

Yesterday's CNN is how everyone has done image recognition for 30 years: stack layers, train, hope it works. Marcella — Bee's own AI — does it totally differently. Every input becomes a point in a geometric space, and the decision comes from where those points cluster. Today you build Marcellette, a kid-sized version of Marcella. We work it out with chalk first: each digit is a point in 3D space, similar digits cluster together, prediction is just "which cluster is this new point closest to?" You can literally see the AI thinking by watching where the points land.

Build Marcellette in Python. Compute 3 geometric features per digit (centroid, principal axis angle, perimeter-to-area ratio) → project every training digit into a 3D scatter plot, colored by class. Plot rotates live in matplotlib. Then run inference: any new digit gets the same features computed, finds its k-nearest training points, votes for the most common class. Compare Marcellette's accuracy against Day 3's CNN on the same test set — Marcellette won't beat the CNN at raw accuracy, but you'll be able to see exactly why it predicts what it does (which the CNN can't tell you). Then point your phone camera at a hand-drawn digit on paper — your laptop runs Marcellette live and tells you what it sees. Bonus: shoot 50 photos of something you care about on your phone, run Marcellette on those, and ask "do these cluster geometrically?"

Build Marcellette in Python. Compute 3 simple features for each digit → plot every training digit as a colored dot in 3D space. The plot rotates live on screen. Then run it: a new digit lands in the cloud, looks at its nearest neighbors, votes for what it is. Marcellette won't beat the CNN at raw accuracy, but it can show you exactly why it picked what it did (which the CNN can't). Then point your phone camera at a digit you drew on paper — Marcellette tells you what it sees, live. Bonus: shoot 50 photos of something you care about and ask "do these cluster?"

Polish both models — the Day 3 CNN AND your Day 4 Marcellette. Prep a three-minute talk in your own voice. Design a one-page poster comparing the two: on the left, the CNN architecture diagram (layers, weights, the "black box" parents expect to see); on the right, Marcellette's geometric scatter plot showing exactly where each digit lives in 3D space. We print on cardstock at noon. The "look how the AI thinks" image on the right is the one parents put on the fridge.

Polish both models — the CNN AND Marcellette. Prep a three-minute talk in your own voice. Design a one-page poster: CNN on the left (the "black box" parents expect to see), Marcellette on the right (the 3D scatter showing exactly where every digit lives). Print on cardstock at noon. The geometric picture is the one parents put on the fridge.

Parents arrive at 1:30. Science-fair setup: each camper at a laptop running BOTH models on a live webcam. Parents hold up their car keys, sunglasses, a handwritten note. CNN says "I think it's an X with 87% confidence." Marcellette says "it lives in this cluster of the geometric space, closest to these three training examples — that's why I called it an X." You walk parents through both, and you'll see most parents pay closer attention to Marcellette because they can see the reasoning. Real questions, real audience, no slides. We close at 3 with a certificate ceremony.

Parents arrive at 1:30. Science-fair setup: you at a laptop running both models on a webcam. Parents hold up keys, sunglasses, a sticky note. CNN says "I think it's an X — 87% sure." Marcellette says "it lives in this cluster, near these three training examples — that's why I called it an X." Most parents pay closer attention to Marcellette because they can see the reasoning. Real audience, no slides. Certificate ceremony at 3.

Three big ideas: inertia (Newton's first — moving things keep moving), centripetal force (why a moving thing curves around a heavy thing), and conservation of angular momentum (why a satellite speeds up as it dips closer to Earth). Hands-on: tie a tennis ball to a string and swing it overhead. Cut the string. Watch where it flies. That's orbital mechanics in one motion. We chalk-draw the geometry on the parking lot at 25-foot scale — Earth in the center, an ISS orbit traced out at the right ratio.

Three big ideas. Moving things want to keep moving. Moving things curve around heavy things. A satellite that dips closer to Earth speeds up. Tie a tennis ball to a string, swing it over your head, cut the string. Watch where it flies. That's how orbits work. We chalk the geometry on the parking lot at 25-foot scale — Earth in the middle, the ISS's orbit traced around it.

Build it in Python. Set up Earth as a 5.97×10²⁴ kg point mass. Drop a satellite in at 400 km altitude with 7.66 km/s tangential velocity — the ISS's real numbers. matplotlib animates the orbit. Then mess with it: lower the velocity by 10% and watch the satellite fall; raise it by 10% and watch it escape; plot the eccentricity-vs-velocity curve. The failures are the lesson.

Build it in Python. Earth in the middle. Drop a satellite at the ISS's real altitude and speed. Watch the orbit animate on screen. Then break it: cut the speed by 10% and watch the satellite fall to Earth, raise it 10% and watch it escape into deep space. The failures are the lesson.

A real CubeSat has five subsystems and every one of them fights for the same budget: EPS (power — usually 2W of solar at peak), CDH (the onboard computer, typically an embedded ARM), ADCS (attitude control — how does it know which way it's pointing?), COMM (the radio link back to Earth, usually amateur-radio S-band), and the payload (the actual science instrument). A 1U CubeSat is 10×10×10 cm and masses 1.33 kg. Every gram counts. We work through the budget on a real spreadsheet.

A real CubeSat has 5 parts, and all 5 fight for the same tiny budget: power, brain, pointing system, radio, and the science instrument. The whole satellite is about the size of a softball and weighs about as much as a small backpack — every gram counts. We work through it on a real spreadsheet, the same kind NASA actually uses.

Pick a mission you actually care about — wildfire detection over the Sierra, ocean-plastic spotting, tracking a comet, listening for radio bursts from space. In teams of 3-4, spec the CubeSat that does it: which subsystem matters most, what gets cut when mass runs out, what the orbit and lifetime look like. We sketch the bus on paper, then in Tinkercad. By the end of the day each team has a one-page mission spec and a downlink budget showing how much data you can send home per day.

Pick a mission you actually care about — wildfire spotting, tracking ocean plastic, hunting for radio bursts from space. In teams of 3-4, design the CubeSat that does it: which part matters most, what gets cut when you run out of weight, how long it can stay alive in orbit. Sketch on paper, then in Tinkercad. By end of day each team has a one-page mission spec.

Bus to the Chabot Space & Science Center in Oakland — about 90 minutes each way with a chartered driver and parent-signed transportation consent already on file. On-site: the Apollo capsule, the Challenger replica, Nellie (Chabot's 36-inch refracting telescope from 1915), and the planetarium show "Forward! To the Moon." Lunch in the cafeteria. We give you a worksheet of three engineering puzzles to solve while you're there — the answers are hiding in the exhibits.

Bus to the Chabot Space & Science Center in Oakland — about 90 minutes each way, parents already signed the transportation form. On-site: the Apollo capsule, the Challenger replica, Nellie the giant 1915 telescope, and a planetarium show about going to the Moon. Lunch in the cafeteria. You get a worksheet of three engineering puzzles — the answers are hiding in the exhibits.

Back at the venue around 2 PM. Build your rocket: Estes Alpha III kit, A8-3 engine (just under one second of thrust, 80 m peak altitude). Sand the fins. Glue the body tube. Slide in the engine. Your name goes on the fin in permanent marker. Pre-flight inspection by Bee. Tomorrow they fly.

Back at the venue around 2 PM. Build your rocket — a real Estes Alpha III with a real engine. Sand the fins. Glue the body tube. Slide in the engine. Your name goes on a fin in permanent marker. Bee does a pre-flight check. Tomorrow they fly.

Walk to the field with the launch pad and the safety perimeter. Pre-flight check on every rocket: engine seated, igniter clipped, recovery wadding loaded, parachute folded. Range Safety Officer (Bee) gives the count: 5, 4, 3, 2, 1, fire. Your rocket leaves the ground at ~80 km/h, peaks at ~80 m, parachute deploys, drifts down. We track which rockets make it back vs. which don't. Each kid runs the post-mortem on their own flight — what could you change?

Walk to the field with the launch pad and safety perimeter. Pre-flight every rocket. Bee (the Range Safety Officer) counts down: 5, 4, 3, 2, 1, fire. Your rocket goes up about 80 meters, the parachute pops, and it drifts back down. We track which rockets come back vs. which don't. You run the post-mortem on your own flight — what would you change next time?

Back inside, calmer. Each team designs the mission patch for the CubeSat you specced on Day 2 — circular, with the mission name, your team's call sign, and one symbol of what the mission does. Hand-sketch on paper, scan, vectorize, then heat-press onto a felt patch. By 3 PM the patch is on your camp bag. Embroidered, not iron-on. Yours forever.

Back inside, calmer. Each team designs the mission patch for the CubeSat from Day 2 — circle shape, mission name, your team's call sign, and one symbol of what the mission does. Sketch on paper, scan, vectorize, then heat-press onto a felt patch. By 3 PM the patch is on your camp bag. Embroidered, not iron-on. Yours forever.

Mission-book day. Your team takes everything from the week — orbital math, CubeSat spec, mission patch, launch log — and binds it into one printed book. Cover design, table of contents, the works. We print and perfect-bind at lunch on the venue's risograph. Then prep the briefing: ten minutes, three slides, three questions you expect parents to ask.

Mission-book day. Take everything from the week — orbital math, CubeSat spec, mission patch, launch log — and bind it into one printed book. Cover design, table of contents, the works. We print and bind at lunch on the venue's risograph. Then prep the briefing: 10 minutes, three slides, three questions you expect parents to ask.

Parents arrive at 1 PM. Each team briefs their mission — the same way real NASA mission teams brief stakeholders before a launch. Then we deploy: every camper opens the DGSA WebXR app on a phone, points it at the parking lot, and watches their team's CubeSat appear in AR over their head. It orbits in real time, tracked against your team's planned orbital parameters. Parents see it through their own phones. You did this.

Parents arrive at 1 PM. Each team briefs their mission — the way real NASA teams brief before a launch. Then we deploy: every camper opens the DGSA WebXR app on a phone, points it at the parking lot, and your team's CubeSat appears in AR, orbiting in real time over your head. Parents see it through their own phones. You did this.

Threat modeling — Microsoft's STRIDE framework, six categories of how things go wrong: Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege. We apply it to three targets: your phone, your bedroom, and your school's Single Sign-On. For each, you draw the trust boundaries and find at least one attack from every STRIDE category. You'll never look at "Forgot password?" the same way again.

Threat modeling — Microsoft's STRIDE: six categories of how things go wrong. Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege. We apply it to your phone, your bedroom, and your school login. You draw the trust boundaries and find at least one attack from each category. You'll never look at "Forgot password?" the same way again.

Bee opens the test door. Three locks pinned at three difficulty levels: a Kwikset KW1 (the most common residential lock in America, pickable in 30 seconds with practice), a Schlage SC1 (the next step up), and a tubular dimple lock (harder, requires a curved pick). You learn the difference between single-pin picking and raking, why most attacks are bypass not pick, and exactly when a lock-picking tool stops being a learning aid and becomes a weapon. Strictly tools-down once the lesson is over — the picks go in Bee's lockbox.

Bee opens the test door. Three locks at three difficulty levels: the most common house lock in America, the next step up, and a hard one with a curved pick. You learn single-pin picking vs. raking, why most break-ins are actually bypasses (not picks), and exactly when this turns from a learning aid into something serious. Tools-down once the lesson is over — picks go in Bee's lockbox.

How passwords really work. We trace one keystroke from your keyboard through the salt, through the hash function (SHA-256, BCrypt, scrypt), into the database. Then we cover the four ways attackers get them back out: dictionary attacks (try the top 10,000 passwords), rainbow tables (precomputed hash lookups), credential stuffing (reusing leaks from other sites), and good old phishing. Live demo: we compute SHA-256 of "password" in 2 milliseconds on the projector, then look up that hash in a free rainbow table and find the plaintext in 200 ms. That's why salt exists.

How passwords actually work. We trace one keystroke from your keyboard → through the salt → through the hash function → into the database. Then we cover the four ways attackers get them back out: try the top 10,000 (dictionary), use precomputed tables (rainbow), reuse leaks from other sites, or just phish you. Live demo on the projector: "password" becomes a hash in 2 milliseconds, then a free lookup table cracks it in 200 ms. That's why salt exists.

Build a Python password strength analyzer that catches dictionary attacks, character substitutions (p@ssw0rd), birthday patterns (mm-dd-yyyy), and keyboard walks (qwerty, asdf). Score every password on entropy bits — and learn why a 4-word passphrase from xkcd is stronger than a random 8-character string most humans can type. Test it on the rockyou.txt leak (a famous 2009 password dump used for security research, still the standard benchmark) and watch your analyzer label 90% of those passwords as "easily cracked."

Build a password strength checker in Python. It catches dictionary words, character swaps (p@ssw0rd), birthdays, and keyboard walks (qwerty, asdf). Score each password on how much actual randomness it has — and find out why a 4-word passphrase is stronger than an 8-character mess most humans can type. Test it against rockyou.txt (a real, famous leak) and watch your checker label 90% as "easily cracked."

How the internet actually moves a packet. We trace one HTTPS request from your laptop, through your router, your ISP, the backbone, the destination server. What your ISP can see (the domain you're visiting, how much data) vs. what it can't (the contents of the page). DNS, SNI, ECH, the bits of the connection that still leak. Live demo: Wireshark on a sandbox network, watching the TLS handshake happen one packet at a time.

How the internet actually moves a packet. We trace one click from your laptop → through your router → through your ISP → through the backbone → to the destination server. What your ISP can see vs. what it can't. Live demo: Wireshark on a sandbox network, watching the encryption handshake happen one packet at a time.

Build a Faraday cage from aluminum foil and a cardboard box. Drop a donated cell phone inside, close the lid, watch the signal bars drop to zero in about 2 seconds. We test which frequencies the foil blocks (cellular 850 MHz, Wi-Fi 2.4 GHz, GPS 1.575 GHz — all gone) and which it doesn't (audible sound passes right through). Then take that donated old phone apart with a screwdriver kit. Open the back. Find the SIM, the eMMC, the antennas. See where your data physically lives.

Build a Faraday cage from aluminum foil and a cardboard box. Drop a donated cell phone inside, close the lid, watch the bars drop to zero in about 2 seconds. We test which signals the foil blocks (cell, Wi-Fi, GPS — all gone) and which it doesn't (sound passes right through). Then take that donated phone apart with a screwdriver kit. Open the back. Find the SIM, the storage, the antennas. See where your data physically lives.

Live demos of three classic attacks — in a controlled sandbox that has nothing to do with the real internet. SQL injection: we type ' OR '1'='1 into a login form Bee wrote bad on purpose, and we're in. XSS: we paste <script>alert('hi mom')</script> into a comment field and the next visitor sees the popup. Social engineering: Bee role-plays a phone call pretending to be IT, and we count how many of you would have handed over your password if she'd asked your real-life self. The answer is sobering.

Live demos of three classic attacks — in a sandbox, nothing connects to the real internet. SQL injection: Bee made a login form bad on purpose, we type some sneaky text, and we're in. XSS: we paste a snippet into a comment box and the next visitor sees a popup we wrote. Social engineering: Bee role-plays a fake IT phone call, and we count how many of you would have handed over your password. The answer is uncomfortable.

Build defenses against the three attacks you just watched. Patch the SQL injection with parameterized queries. Patch the XSS with HTML escaping. Patch the social engineering with a verification protocol (call back on a known number, not the one they gave you). You'll fix code you wrote yesterday and the morning's example sites, and write a one-page "what we'd do at IBM X-Force" memo on each one.

Build defenses against the three attacks you just watched. Patch the SQL hole. Patch the comment box. Write a verification protocol for the phone call (call back on a known number, never the one they gave you). You'll fix the code you wrote yesterday, plus the example sites, and write a one-page "what we'd do at IBM" memo on each.

Team CTF kicks off at 9:15. Twelve flags hidden in three categories. Crypto: four Caesar/Vigenère/base64 puzzles on the sandbox network — solve the cipher, read the flag. Forensics: four flags hidden in metadata, pcap files, and stripped-out EXIF data on photos Bee provided. Physical: four flags taped under chairs, hidden inside library books at the venue, and one locked in a small combination box you crack with a 4-digit combo whose digits are in a Python script you have to read. The scoreboard is live on the projector all morning.

Team CTF starts at 9:15. Twelve flags in three categories. Crypto: four cipher puzzles on the sandbox network — solve the code, read the flag. Forensics: four flags hidden in photo metadata and packet captures. Physical: four flags taped under chairs, hidden inside library books, and one locked in a small combination box you crack with a 4-digit code hidden inside a Python script you have to read first. Live scoreboard on the projector all morning.

Parents arrive at 1:30 for awards and demos. Each team walks their family through how they solved at least three flags — the lock-picking, the password-cracking, the network sniffing — all in plain language. Trophies for first place; "Junior Security Analyst" certificate for everyone. Bee hands out the take-home kits: USB data blocker (stops a public USB port from reading your phone), RFID-blocking sleeve for your school ID, and the screwdriver kit you opened a phone with on Wednesday.

Parents arrive at 1:30 for awards. Each team walks their family through how they solved at least three flags — the lock-picking, the password-cracking, the network sniffing — all in plain English. Trophies for first place; everyone gets a Junior Security Analyst certificate. Bee hands out take-home kits: USB data blocker, RFID-blocking sleeve for your school ID, and the screwdriver kit from Wednesday.

Vectors, dot products, and why every video game, AI system, and GPS uses them constantly. We sketch the basics with chalk on the parking lot at 50-foot scale — a giant coordinate plane you can walk through. Find the dot product of two vectors by literally walking along one and measuring the shadow you cast on the other. By 11 AM you can compute a 2D rotation matrix in your head and explain why cos²θ + sin²θ = 1 is just the Pythagorean theorem in disguise.

Vectors, dot products, and why every video game, AI, and GPS uses them all the time. We sketch the basics with chalk on the parking lot at 50-foot scale — a giant coordinate plane you can walk through. Find the dot product of two vectors by literally walking along one and measuring the shadow you cast on the other. By 11 AM you can do a 2D rotation in your head.

Build a 2D physics simulator from scratch in pygame — gravity (9.8 m/s²), elastic collisions (coefficient of restitution 0.7), drag. Twenty bouncing balls in a box. The math is exactly what you sketched on the parking lot, just executed 60 times a second. Then make a tiny playable game out of it: paddle, ball, brick wall. Breakout in 80 lines of Python.

Build a 2D physics simulator from scratch in pygame — gravity, bouncing, drag. Twenty bouncing balls in a box. The math is exactly what you sketched on the parking lot, just running 60 times a second. Then make a tiny game out of it: paddle, ball, brick wall. Breakout in 80 lines of Python.

Modular arithmetic and prime numbers — why these protect every text message you send. We start with the clock-arithmetic intuition (it's 10 AM, what time is it in 5 hours? 3 PM — that's mod 12), then build up to Fermat's Little Theorem and why a^(p-1) ≡ 1 (mod p) is the magic that makes RSA work. We use small primes (p=11, q=13, n=143, φ(n)=120, e=7, d=103) so you can do every step on paper.

Modular arithmetic and prime numbers — the math that protects every text you send. Start with clock math (it's 10 AM, what time is it in 5 hours? 3 PM — that's mod 12). Build up to the trick that makes RSA encryption actually work. We use small primes so you can do every step on paper.

Build a working toy RSA encryption tool in Python. Encrypt your initials to a number using a real key pair (small but real). Then the keep-and-deliver project: write a sealed letter to your future self — anything you want to tell the version of you reading it six months later — encrypt it with your own key, and seal it in an envelope addressed to your parents. We mail those envelopes back to your parents in December. You decrypt at home with the key you took with you. Real cryptography, real mail.

Build a working RSA encryption tool in Python. Encrypt your initials into a number using a real (small but real) key pair. Then the keep-and-deliver project: write a sealed letter to your future self — anything you want to tell the version of you reading it six months later. Encrypt it with your own key. Seal it in an envelope addressed to your parents. We mail those envelopes back in December. You decrypt at home with the key you kept. Real cryptography, real mail.

Probability and Bayesian reasoning — how doctors, weather forecasters, and AI all think. We work through the classic medical-test problem: a disease affects 1 in 1,000 people, the test is 99% accurate, you test positive — what's the actual chance you have it? (Answer: about 9%, which surprises most adults.) Then we cover prior beliefs, likelihood, evidence-updating — the formal Bayes' rule, named for a guy who never published it in his lifetime.

How doctors, weather forecasters, and AI all think — using probability. We work the classic medical-test puzzle: a disease affects 1 in 1,000 people, the test is 99% accurate, you test positive — what's the actual chance you have it? (About 9%. Surprises every adult who tries it.) Then we cover Bayes' rule, the formal version, named for a guy who never published it in his lifetime.

Predict tomorrow's Sacramento weather (for real) using a naive Bayes classifier you write yourself. We pull 30 years of NOAA daily-weather data for Sacramento from a CSV. You train on the first 28 years, test on the most recent 2, predict tomorrow. Friday we compare your prediction against the actual high temperature — closest team gets a prize. You'll discover that "tomorrow is like today" is a surprisingly hard baseline to beat.

Predict tomorrow's Sacramento weather, for real, using a Bayes classifier you write yourself. We pull 30 years of NOAA weather data from a CSV. You train on the first 28 years, test on the last 2, predict Friday. Closest team to the actual high temperature wins a prize. You'll find out "tomorrow is like today" is a shockingly hard baseline to beat.

How three satellites can locate any phone on Earth using basic geometry. The math is trilateration — three known points, three measured distances, one unique intersection. We work the equations on the whiteboard: you have a circle of radius d₁ around satellite A, a circle of d₂ around B, a circle of d₃ around C. Where they all intersect is where you are. Two satellites give an ambiguous answer; three pin it down; four corrects for clock drift. You can totally do this math.

How three satellites can locate any phone on Earth using basic geometry. The trick is trilateration: three known points, three measured distances, one unique answer. We do the math on the whiteboard. A circle around satellite A. A circle around B. A circle around C. Where they all overlap is where you are. Two satellites give an ambiguous answer; three pin it down; four corrects for clock drift. You can definitely do this.

GPS scavenger hunt across the venue. Three "satellites" (sticks in the ground at known coordinates) and four hidden prize caches. For each cache we give you three measured distances (in meters, from each satellite). You compute the latitude/longitude on paper using the trilateration math from the morning. First team to all four caches picks the grand prize first. Then we hand out cheap handheld GPS receivers and confirm your math against what the satellites say.

GPS scavenger hunt across the venue. Three "satellites" (sticks in the ground at known spots) and four hidden prize caches. For each cache we tell you the three distances from the satellites. You do the trilateration on paper to find the latitude/longitude. First team to all four picks the grand prize first. Then we hand out cheap handheld GPS receivers and check your math against what the real satellites say.

Fold an origami fractal sculpture — a Sierpinski tetrahedron, the 3D version of the famous triangle. Four small tetrahedra make one big tetrahedron; sixteen small ones make level 2; sixty-four make level 3. We fold to level 3 — that's 64 little pyramids glued into one big one — and you can hold it in two hands. The fold instructions ARE math: you're literally executing a recursive function with paper.

Fold an origami fractal sculpture — a Sierpinski tetrahedron, the 3D version of the famous triangle. Four little pyramids make a bigger one; sixteen make level 2; sixty-four make level 3. We fold to level 3 — 64 little pyramids glued into one big one — and you can hold it in two hands. The fold instructions ARE math: you're running a recursive function with paper.

Stitch the week together into one printed zine: physics simulator code, RSA key, Bayes weather predictor, trilateration log, Sierpinski photo. Layout in Affinity Publisher (we provide the template). Print on the venue's risograph — 12 pages, two-color, hand-bound at the spine. Then present one concept to peers and parents. Teaching is the deepest learning, and you'll feel it.

Stitch the week into one printed zine: physics sim code, RSA key, weather predictor, GPS log, Sierpinski photo. Layout in Affinity Publisher (we give you the template). Print on the venue's risograph — 12 pages, two-color, hand-bound at the spine. Then present one idea to peers and parents. Teaching is the deepest learning — you'll feel it.