A 10-week expedition through computer engineering, the mind, and society — to figure out what you actually want to build, study, and become
$ ./discover.sh --summer 2026 --mode hands-on --player eli
This is the big quest. Instead of learning one skill, you're going to test-drive possible futures. Psychology, neuroscience, computer science, biotech, data science — or a gap year doing AV professionally. Right now those are five-and-a-half doors you haven't opened. By the end of August, you'll have actually stood inside each room for a while, and you'll know which ones felt like yours.
The rule that makes this work: you can't think your way to this answer — you have to do things and notice how they feel. Every module here is hands-on: building circuits, writing code, running experiments on your family, sitting in a coffee shop taking field notes like a sociologist. The data you're collecting isn't about resistors or p-values. It's about you.
Most of the summer goes to computer engineering (code + electronics), because it's the deepest rabbit hole and the one that overlaps most with your AV/theater world. Then three short "side quests" — research psychology, criminology, sociology — to see if any of them spark something. The final week is the Boss Battle: turning everything you noticed into an actual decision.
Click any module header to expand it. Work roughly in order — the week map below shows the suggested schedule. Check off items as you go (progress saves in your browser). At the end of each module, give it a Spark Rating — those ratings get charted in the final module and become real data for your decision.
You're a better writer than 99% of people your age — so this quest's main instrument is a journal. After every session, write 3–5 sentences answering: What did I do? What was the most interesting moment? Did time fly or drag? Plain text file, notes app, or paper — whatever you'll actually use. (Module 1 includes an optional terminal script that makes journaling a 30-second command, but a notes app counts just as much.)
In Week 10, this journal is the evidence you'll use to choose a direction. Future Eli is counting on present Eli to write it down.
Ten weeks, mid-June to late August. Aim for 4–5 sessions a week, 45–90 minutes each. This is a map, not a contract — if a module takes longer because you're loving it, that's not falling behind. That's data.
| Week | Focus | Module |
|---|---|---|
| Week 1 (Jun 15) | Gear up + Python foundations | 1 & 2 |
| Week 2 (Jun 22) | Finish Python, start electronics | 2 & 3 |
| Week 3 (Jun 29) | Electronics, first Arduino sketches | 3 & 4 |
| Week 4 (Jul 6) | Arduino deep dive | 4 |
| Week 5 (Jul 13) | Audio electronics & MIDI lab | 5 |
| Week 6 (Jul 20) | Raspberry Pi | 6 |
| Week 7 (Jul 27) | Capstone build | 7 |
| Week 8 (Aug 3) | Side quest: research psychology | 8 |
| Week 9 (Aug 10) | Side quests: criminology + sociology | 9 & 10 |
| Week 10 (Aug 17) | Boss Battle: choose your class | 11 |
Order these in the first couple of days so they arrive before you need them. Core gear is roughly $80–100; the optional items add the Raspberry Pi module and some side quests.
| Item | Approx. Cost | Needed For |
|---|---|---|
| Elegoo UNO R3 Super Starter Kit (or similar Arduino-compatible kit with breadboard, LEDs, resistors, buttons, potentiometers, buzzer, LCD, sensors, jumper wires) | ~$50 | Modules 3, 4, 5, 7 — the backbone of the summer |
| Digital multimeter (any basic auto-ranging one) | ~$15–25 | Module 3 — measuring voltage, current, resistance |
| Arduino Pro Micro or Leonardo (a board with native USB — it can pretend to be a keyboard or MIDI device) | ~$12–20 | Module 5 — building a real MIDI controller |
| Optional: Raspberry Pi 5 kit (board, power supply, SD card, case) | ~$100–130 | Module 6 — can be skipped or substituted (see that module) |
| Optional: PAM8403 mini amplifier board + small 4–8Ω speaker | ~$10–15 | Module 5 side quest — build a working speaker rig |
| Optional: Pulse sensor for Arduino (e.g., PulseSensor or MAX30102 module) | ~$10–15 | Module 8 side quest — a taste of biotech/neuro-style measurement |
Free software you'll install along the way: Arduino IDE, Python 3 (already on your Mac), VS Code, and GarageBand (already on your Mac — it'll be the receiving end of your MIDI controller).
Set up a dedicated spot where the breadboard and wires can stay out all summer. This matters more than it sounds: if every session starts with unpacking, sessions won't start. A desk corner, a tray you can slide under your bed, anything — as long as a half-finished circuit can survive there untouched.
~/summer-quest/ folderFirst build: the tool you'll use all summer — a tiny script that timestamps and saves a journal entry from the terminal. If you've done the Shell Script Quest, this will read like an old friend. If you haven't, copy it exactly as written — it works either way (or skip the script entirely and use a notes app; the journal is what matters, not the tooling).
#!/bin/bash
# journal.sh - one-command field journal
journal_dir="$HOME/summer-quest/journal"
mkdir -p "$journal_dir"
entry_file="$journal_dir/$(date +%Y-%m-%d).md"
echo "" >> "$entry_file"
echo "## $(date +%H:%M)" >> "$entry_file"
echo "What did you do? Most interesting moment? Time fly or drag?"
echo "(Type your entry, then Ctrl+D on a blank line to save)"
cat >> "$entry_file"
echo "Saved to $entry_file"Now journaling is: open terminal, type journal, write three sentences, Ctrl+D, done. Thirty seconds.
~/summer-quest/journal.sh, then make it runnable: chmod +x ~/summer-quest/journal.shecho 'alias journal=~/summer-quest/journal.sh' >> ~/.zshrc then source ~/.zshrcThe five majors you're weighing aren't really five separate things — they're points on two axes: building things vs. studying people, and more math/code vs. less. Computer science, computer engineering, and data science live on the "building" side. Psychology, neuroscience, and sociology live on the "people" side — and neuroscience, biotech, and data science sit in the overlap. By the end of the summer you'll know which axis pulls harder, which narrows five options to two or three fast.
journal.sh built, aliased, and testedPython is what you'd use in an actual CS course, a data science job, or a psychology research lab — it's the common language of four of your five candidate majors. (If you've done the Shell Script Quest, you already know half the ideas here — variables, loops, if/else all have Python twins. If you haven't, no problem: Python is the friendlier place to start anyway.)
Check it's installed, then start the interactive interpreter:
python3 --version
Python 3.x.x
python3
>>> print("Hello, Eli")Here's a d20 roller two ways — a shell script version next to the Python version (the comparison is instructive even if you've never written the first kind):
# bash version (the Shell Script Quest way)
d20=$(( (RANDOM % 20) + 1 ))
# Python version (save as roll.py, run with: python3 roll.py)
import random
d20 = random.randint(1, 20)
print(f"You rolled a {d20}!")~/summer-quest/python/3d6 as input, print each roll and the total. (Shell Script Quest veterans: this is a port of your dice-roller.sh — compare the two when you're done)10-minute version: just get roll.py running.
Python's lists hold collections of things (if you've met bash arrays: like those, but they don't fight you):
party = ["Thaldrin", "Mira", "Korvath"]
party.append("Ezri")
for member in party:
initiative = random.randint(1, 20)
print(f"{member} rolls {initiative} for initiative")
def roll_dice(sides, count):
return [random.randint(1, sides) for _ in range(count)]Build an initiative tracker: enter character names, roll initiative for each, print the turn order sorted high to low (look up sorted() with key=). This is the D&D combat simulator's heart, in about 15 lines.
Here's where Python leaves bash behind. You wrote an extensive fantasy story — let's run analytics on it. Export it as a plain text file, then:
from collections import Counter
with open("my_story.txt") as f:
text = f.read().lower()
words = text.split()
print(f"Total words: {len(words)}")
print(f"Unique words: {len(set(words))}")
print("Top 20 words:", Counter(words).most_common(20))Then go further: how often does each character's name appear, chapter by chapter? Who dominates the middle of the story and disappears at the end? This is literally what data science is — asking questions of data you care about. If this session is the one where time disappears, write that down. It's a big clue.
Build a soundboard app in Python — press a key, play a sound. The tool you've run a hundred times from the booth, now built by you.
pip3 install pygamepygame.mixer and the key event loopUnbox the kit and identify everything: breadboard, jumper wires, LEDs, resistors (learn to read the color bands — there's a chart in the kit), buttons, potentiometers. Then build the simplest possible circuit, powered by the Arduino's 5V pin (using it purely as a power supply — no code yet):
Nothing in this kit can hurt you — 5 volts can't push enough current through skin to feel. The things at risk are the components: always put a resistor in series with an LED, never connect 5V directly to GND (short circuit), and unplug USB power while rewiring. Wall outlets and mains voltage are a different universe — this curriculum never goes there.
Ohm's law is the entire foundation: V = I × R (voltage = current × resistance). Don't memorize it — verify it:
Impedance, gain staging, why you don't plug a mic-level signal into a line-level input, why long unbalanced cables hum — the mixing boards you already operate are applied Ohm's law. This module is the theory under skills you already have.
Build (no code!) a three-channel status panel like the ones outside studio doors:
An Arduino is a tiny computer with no screen and no keyboard — just pins that can sense and control electricity. This is embedded programming: the chips inside sound boards, lighting consoles, pacemakers, and Mars rovers. Computer engineering, as opposed to computer science, lives exactly here.
void setup() {
pinMode(LED_BUILTIN, OUTPUT); // runs once at power-on
}
void loop() { // runs forever, like a while true
digitalWrite(LED_BUILTIN, HIGH);
delay(1000); // milliseconds
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}Read a button, control an LED. This is the actual circuit of a stage manager's cue light system: SM presses a button in the booth, light goes on backstage, performer goes on cue.
const int buttonPin = 2;
const int ledPin = 13;
void setup() {
pinMode(buttonPin, INPUT_PULLUP); // button wires pin 2 to GND
pinMode(ledPin, OUTPUT);
}
void loop() {
if (digitalRead(buttonPin) == LOW) { // pressed
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
}Buttons are on/off. The real world is continuous — and so are faders. Wire the potentiometer to analog pin A0 and read it (0–1023), then use PWM (analogWrite, 0–255) to dim an LED with it. You've built a one-channel dimmer board: fader in, light level out. This pot-to-PWM pattern is the core of half of all embedded devices.
Open Tools → Serial Plotter while it runs and watch your fader moves draw a live graph — your first sensor data visualization.
The passive buzzer in your kit can play tones with tone(pin, frequency, duration). Frequencies are real: A4 = 440 Hz, the note orchestras tune to (you've heard it at every strings festival you've mixed).
Transcribe the first phrase of the Doctor Who theme into an array of frequencies and durations, and make the buzzer play it. (Search "note frequency chart" — the theme starts around B2/E3 territory. It will sound gloriously terrible on a buzzer. That's the point.)
Build a reaction-time tester — and keep the data, because in Module 8 you'll analyze it like a psychology researcher. (This gadget is secretly a bridge between two of your possible majors.)
random() and millis())Serial.println(reactionTime)You've routed audio signals for years. This week: what's physically inside the cable. Sound is pressure waves; a microphone turns them into a tiny wobbling voltage; everything in your booth is just machinery for moving, mixing, and amplifying that voltage.
For each concept, write the explanation you'd give a freshman joining the AV crew. If you can explain gain staging in writing to a beginner, you understand it better than most working techs — and you'll have writing samples for tech theater program applications, if it comes to that.
MIDI isn't audio — it's messages about music and control: "note on," "controller 7 to value 100." QLab, Ableton, lighting consoles, and digital mixers all speak it. Your Pro Micro/Leonardo has native USB, which means it can be a MIDI device as far as your Mac is concerned.
Wire a potentiometer and send its position as a MIDI control change message (CC). Map it in GarageBand to volume. Move your physical fader, watch the on-screen fader follow. Every $3,000 control surface in every booth is exactly this, times 32 channels, in a nicer case.
Build a working MIDI controller you could legitimately use in the booth next year:
An Arduino runs one program. A Raspberry Pi runs Linux — a full operating system. You'll set it up headless (no monitor) and control it entirely from your Mac's terminal over SSH. If you've done the Shell Script Quest, this is the payoff moment — every command you learned works here. If you haven't, you only need a handful of commands to get by, and that quest is waiting whenever you want the full tour.
ssh pi@raspberrypi.localpwd, ls, write a script — it's all there. This is exactly how engineers run servers and how show-control computers get managed in venues.If the budget says no, do this module's ideas without it: the SSH experience can be simulated by enabling Remote Login on your Mac and SSHing into it from itself, and the Flask web-app session below runs fine on macOS. The GPIO (hardware pins) part is the only piece that truly needs the Pi.
The Pi has GPIO pins like an Arduino, but you drive them from Python. Wire an LED + resistor to a GPIO pin and:
from gpiozero import LED
from time import sleep
cue_light = LED(17)
while True:
cue_light.on()
sleep(1)
cue_light.off()
sleep(1)Same blink as Module 4 — but now it's one program among many on a networked computer. Feel the difference between a microcontroller (Arduino: dead-simple, instant-on, never crashes) and a microprocessor system (Pi: powerful, networked, complex). Choosing between them for a job is a core computer-engineering judgment call.
Install Flask (pip3 install flask) and build a tiny web app on the Pi: one page, two buttons — "Cue Light ON" and "Cue Light OFF." Visit it from your phone's browser. You've built a networked control system: phone → Wi-Fi → web server → GPIO → light. That's the architecture of smart homes, venue control systems, and every IoT product.
One week, one project that combines code + hardware. Pick the one you'd actually use — or pitch your own. The goal isn't polish; it's the experience of carrying an engineering project from idea to working demo. Pay attention to how this week feels: this is the closest preview of what engineering school and engineering work are actually like.
Productionize Module 6's prototype: multiple stations (Pi + LEDs, or Pi controlling Arduinos), a stage-manager web panel with named channels ("SR wing," "Booth," "Orchestra"), acknowledge buttons so performers can confirm standby. Dream spec: something you could pitch to your school's theater director for an actual show next year.
Take the Module 5 controller from breadboard to device: more buttons, a real enclosure (project box, drilled holes, labels), maybe a second fader. Then write the companion documentation: a user manual and a "how I built it" writeup with schematic. Build quality + documentation is what separates a project from a product.
Use the kit's LCD1602 display + buttons to build a physical initiative tracker / dice tower companion: roll virtual dice with a button press, display turn order, track rounds, buzz when someone's turn starts. Port your Python initiative tracker logic into Arduino C++ — translating between languages is a deeply instructive exercise.
You liked psych class. Important fork in the road: most people picture psychology as therapy. But the psychology major — and the path to neuroscience — is mostly research: designing experiments, collecting data, doing statistics, writing papers. (Sound familiar? It's data science aimed at minds.)
The Stroop effect is the most famous demo in cognitive psychology: naming the ink color of the word BLUE is measurably slower than the word BLUE — your reading reflex interferes. Researchers still use it constantly.
Build it in Python: show color words in random ink colors, subject presses a key for the ink color, program records response time and correctness for ~40 trials, then prints the average for matching vs. mismatching trials. (Terminal version with colored text via the colorama package is fine; a pygame version is fancier.)
Run everyone in the house through it (a small sample — but real science). Predict the effect size first, in writing. Then check: did everyone show the effect? Who had the biggest interference? You are now doing experimental psychology with an instrument you built yourself — which is genuinely how a lot of grad students spend their days.
Write up the Family Stroop Study as a one-page lab report: hypothesis, method, results (with a chart — matplotlib or a spreadsheet), discussion, limitations (tiny sample!). Write it straight, like a real paper. You'll be shocked how official your kitchen-table data looks in format — and this is the single most representative artifact of what a psych/neuro degree involves.
Forget the TV version. Criminology is a research science: why does crime happen, what actually reduces it, how does the justice system behave in practice? Criminologists run studies, analyze huge datasets, and test theories — it's sociology and psychology aimed at one domain, plus a lot of statistics.
The FBI publishes national crime data anyone can explore: the Crime Data Explorer (cde.ucr.cjis.gov). Most big cities also publish their own open crime data — search "your city open data portal."
Psychology asks "why did this person do that?" Sociology asks "why do thousands of people in the same situation do that?" C. Wright Mills called it the sociological imagination: seeing personal experiences as patterns produced by social structures.
The classic sociology method: structured observation. Go somewhere public — a coffee shop, a mall food court, a park, tennis courts — for 45 minutes with a notebook.
This plays to your strengths: it's quiet, observational, and lives or dies on the quality of the writing.
Then peek at the quantitative side: browse the GSS Data Explorer (gssdataexplorer.norc.org) — 50 years of American attitudes, searchable. Pick any long-running attitude question you're curious about and watch fifty years of change get charted in front of you.
The synthesis exercise for all three side quests — a one-page essay. Take a single question: "Why do people break rules?" Answer it three times: as a psychologist (individual minds, impulses, conditioning), as a criminologist (deterrence, opportunity, environment), and as a sociologist (norms, structures, who defines "rules" at all). End with one paragraph: which lens felt most like yours?
You spent ten weeks generating evidence about yourself. Time to analyze it like you analyzed everything else this summer.
First, your Spark Ratings:
Then the deeper source — reread your entire Field Journal, start to finish, with a highlighter mindset. Mark every place you wrote some version of "time flew," "I kept going after the session ended," or "I want more." Also mark every "this dragged." Check the prediction you made in Week 1 — were you right about yourself?
Six candidate paths, scored honestly, 1–5 each. Make it a spreadsheet (or — full circle — a Python script):
| Path | Spark (enjoyed it) | Flow (time flew) | Strength match | Want 4 yrs of it? |
|---|---|---|---|---|
| Computer science | ← score from Modules 2, 6 evidence → | |||
| Computer engineering | ← Modules 3, 4, 5, 7 → | |||
| Data science | ← story analytics, crime data, Stroop analysis → | |||
| Psychology / neuroscience | ← Module 8 (+ pulse sensor side quest for neuro) → | |||
| Sociology / criminology | ← Modules 9, 10 → | |||
| AV career / gap year | ← Module 5 + the interview below → | |||
Biotech check: you didn't do a biotech module, but you collected biotech-adjacent evidence — did the instrumentation side (sensors, measurement, the pulse sensor) pull at you? If yes, biomedical engineering belongs on the matrix; if it never crossed your mind all summer, that's an answer too.
If the matrix says one thing and your gut sinks, that sink IS data — it means a criterion is missing. Add it, rescore, repeat until the numbers and the gut agree. (This trick works for the rest of your life.)
You're better in writing than out loud — so do outreach the writer's way: email first, then a short call or visit with prepared questions. Target two interviews minimum:
Email template skeleton: who you are (rising senior, what you did this summer — "I built a MIDI controller and ran a Stroop experiment on my family" is a fantastic opener), one specific question, ask for 20 minutes. Short. Specific. Sent.
Take your top two directions and check the actual program pages at every school on your visit list. For each: Does the major exist there? What do the intro courses look like? Are there labs/studios/theaters where you could work? (Engineering note from Module 3: if computer engineering tops your list, that meaningfully changes the school math — check which schools offer it directly vs. via dual-degree.) Senior-year payoff: this list tells you what to take and what to do this fall — the psych elective, the CS class, pitching the cue-light system to the theater director.
The final artifact, and it's a writing assignment because that's your superpower. One to two pages:
Share the Character Sheet with your parents over a meal you choose. Not a defense — a briefing. You're not asking permission; you're presenting findings from a ten-week study with n=1 and unusually good instrumentation.
One final prompt: "In May, the five options were a fog. Write a letter to May-you explaining what you know now." Seal it (figuratively). Reread it in May 2027 when you're choosing where to enroll.