Computer Science I

Opening block, and the first coded results.

1. U1-01Complete survey chunk A, cold, before any instruction.
2. U1-02Establish course routines, syllabus, non-negotiables, and the provisional AI rule.
3. U1-03Complete the baseline cognitive instrument, Part 1 and Part 2.
4. U1-04Complete survey chunks B and C.
5. U1-05State what the surveys are for, that they recur in December, and that these responses become the dataset the class analyzes later in the unit.
6. U1-E02Visualize the coded results to answer a question about the class, and identify what the visualization cannot show.

• Aug 10 through 12 are instrument days: survey chunks A, B, and C, cognitive benchmark Part 1 and Part 2, one unscored constructed response.
• Aug 13: U1-E02.
• Aug 14: source reading. No objective code assigned.

Access. What the machine is, what limits it, and where a request goes.

1. U1-E01Compare fixed-response and open-ended items as data sources, and identify a theme no closed item offered.
2. U1-06Account for why the AI in this room does not run on the Chromebook in front of them.
3. U1-07Explain how a computer computes.
4. U1-08Distinguish VRAM, dedicated GPU, iGPU, and unified memory.
5. U1-09Determine what a given machine can and cannot run, and why — the two cards in the teacher's rig as the worked example.
6. U1-10Trace one request twice — same prompt, local stack and commercial cloud — naming each hop on both paths.
7. U1-11Compare what each endpoint is permitted to do with what arrived: local storage against a commercial provider's terms.
8. U1-12Distinguish *nothing persists* from *requests are unlinkable to a person*, and say which claim each system actually makes.

• Aug 17: U1-E01.
• Aug 18: U1-06, U1-07.
• Aug 19: U1-08, U1-09.
• Aug 20: U1-10.
• Aug 21: U1-11, U1-12.

Model internals, and the setup for next week's station work.

1. U1-13Describe pretraining, post-training, freezing, and inference as distinct phases.
2. U1-14Explain parameters at the level of what the model stores.
3. U1-15Explain tokenization at the level of what the model reads, using live token boundaries in MuggsOfPrompts.
4. U1-16Account for why token count, word count, and character count disagree.
5. U1-17Trace a prompt from text to tokens to output, inspecting candidate tokens and their probabilities at three points.
6. U1-18Account for why the model struggles to count letters, spells unusual words oddly, and treats whitespace as meaningful.
7. U1-19Assign a storage type to every field in the survey schema — integer, float, string, boolean, timestamp.

• Aug 24: Stack Unit Day 3 (schematics review), then U1-13, U1-14. MuggsOfPrompts goes live to students at end of block as an access check.
• Aug 25: Stack Unit Day 4 (whose computer are you using — network, server, cloud), then U1-15, U1-16.
• Aug 26: Stack Unit Day 5 (frozen numbers — parameter, pretraining, post-training, freeze, inference, knowledge cutoff), then U1-17, U1-18.
• Aug 27: Rained Out — student conferences and catch-up day.
• Aug 28: Standalone Friday lesson — Two Different Days (training vs inference, tokenization, why runs differ). Sets up next week's four-day station block. Test 1 content cutoff.

What the word better means, changed four times, with the last change testing the previous three.

• Mon Aug 31: Describe, do not judge. Single pass, hedge, specificity. No ranking.
• Tue Sep 1: Judge by correctness. Claim, verify, source. Three checkable claims per response.
• Wed Sep 2: Judge against given criteria. Criterion, subjective, consistent. No answer key.
• Thu Sep 3: Does the ranking hold. Run, variation, stable. Yesterday's prompt run twice more.
• Fri Sep 4: Test 1. Paper, Chromebooks stored.
• U1-19 through U1-26 are displaced by this lab and move later in the semester.

Three days of writing the Lab 1 report from four days of observation.

1. U1-27Distinguish bias originating in training data from bias installed after training.
2. U1-28Locate control at the layer where change is cheap: weights are expensive and frozen; system prompts, tools, and wrappers are editable in seconds.
3. U1-29Demonstrate installed bias in MuggsOfPrompts — author a system prompt, run it against a fixed battery, document the difference in output.
4. U1-30Hold the seed fixed and account for why that is what makes a difference attributable to the prompt at all; then reseed and account for what changes.
5. U1-31Test whether an instruction holds across a battery or only fits one case, and name that failure as overfitting.
6. U1-32Read published system prompts as primary source documents.
7. U1-33Read the system prompts of the tools this class uses, and distinguish a constraint that is *stated* to a model from one that is *enforced* by the architecture around it.
8. U1-34Write a reflection on how they have experienced AI so far.
9. U1-35Write a closing statement of how they intend to use AI academically going forward.
10. U1-36Code the resulting corpus by the method from 23–26: theme it, protect the outlier, synthesize under a prompt that preserves dissent.
11. U1-37Identify social desirability in a corpus written to their teacher, about AI use, in the class that grades AI use — and state what that implies about which findings to trust.
12. U1-38Distinguish uses of AI that build capability from uses that substitute for it, and state what performance under no-AI conditions requires.
13. U1-C39Locate their own position in the synthesis, or find it absent; revise the prompt; adopt the resulting document as the class AI policy.

• Mon Sep 7 Labor Day, Tue Sep 8 School-Site PD. Both out.
• Wed Sep 9: whole-report shape introduced. The Body form opens (three sections — Tue Sep 1 correctness, Wed Sep 2 criteria, Thu Sep 3 length limit). Own exit-ticket form on the last slide.
• Thu Sep 10: Introduction and Conclusion forms open, then live on tabs (Intro, Body, Conclusion) on the right pane. Today students write Intro first, Conclusion second. Own exit-ticket form on the last slide. 4th period's last in-class day.
• Fri Sep 11: structured work time on all three report forms, in a fixed order — Intro, Body, Conclusion. No exit ticket today (4th period is out for a school-wide activity).
• Every report form (not the exit tickets) can be submitted early and reopened with the "Edit your response" link — the newest version is what counts at the Thu Sep 17 afternoon grading run.
• U1-27 through U1-33 were projected across these content days but ceded to the Lab Report writing. They are not taught this week.
• U1-C39 (the class AI policy) is a closing objective and is still owed — the Sep 14 close-out day was used for revising the report, not for the policy work. Needs a decision on where U1-C39 lands.

Legacy Week — the three languages of the web, taught as English grammar. HTML nouns, CSS adjectives, JavaScript verbs. Grammar precision on paper becomes prompt precision to an AI in Week 7.

• Mon Sep 14: Lab 1 close-out Day 4 — Revise. "Better means more checkable, not longer." Students revise their Intro / Body / Conclusion forms sentence by sentence, adding the number, what it is out of, the source, and the pane so a stranger could go check. Own exit-ticket form on the last slide.
• Tue Sep 15: planned as the overview — three grammars on one screen (HTML = nouns + prepositional phrases of place; CSS = adjectives; JavaScript = verbs and adverbs), Reed-Kellogg-style sentence diagrams. In the room it wandered and became HTML day 1. The Tue deck now on the site is the fixed v2 of the overview for next time; it is not what students saw.
• Wed Sep 16: HTML, day 2 — "The First Language." The HTML day proper. HyperText Markup Language, Tim Berners-Lee at CERN 1989-1991, what HTML alone could do before CSS arrived (text hierarchy, links, images, forms, tables). Live iframe of an HTML-only 90s-style personal homepage embedded in the passage. Classwork: 5 HTML observations of 5 different elements (noun + prepositional phrase only). Deck 1 right pane carries 7 MC reading-check items.
• Thu Sep 17: CSS deep dive — "The Adjective Layer." Cascading Style Sheets, Håkon Wium Lie 1994 proposal, CSS1 spec Dec 1996. Adjectives layered on HTML nouns. The historical wrinkle lands here: HTML → JavaScript → CSS was the arrival order (JavaScript actually shipped before CSS). Classwork: 5 HTML+CSS observations (adds one adjective per element). **Lab Report 1 grading run afternoon.**
• Fri Sep 18: JavaScript deep dive — "The Verb Layer." Brendan Eich, ten days at Netscape, shipped Dec 1995. Verbs + triggers — the "when"-clause is the tell that separates a JS verb from a CSS animation. Classwork: 5 full-trilingual observations (noun + prep + adjective + verb-with-trigger). Culmination of the week.
• Every day carries three or four inline layer-progression slides at the end of the Do Now: same button in Just HTML / HTML+CSS / HTML+CSS+JS / and the historical HTML+JS-no-CSS. Definitions of each language live on those slides.
• Legacy Week is not yet coded in the roadmap. The objectives delivered this week do not map cleanly to U1 (data/models), U2 (source verification), or U3 (spec-driven building). Needs a decision on whether Legacy Week gets its own objective codes or is absorbed as prerequisite scaffolding for U3.
• U1-C39 (class AI policy) is still owed — the Sep 14 close-out day was used for revising the report rather than the policy work. Needs a decision on where U1-C39 lands.

Proto-Spec Week — students prompt a model to build their own browser game, layer by layer (HTML/CSS/JS across Tue-Thu), then compress a week of turns into one paragraph that reproduces the game. Grade is reproducibility: paste the proto-spec into an empty MuggsOfVibes session and see what comes back.

• Mon Sep 21: Reproduce, not build. Students pick one MuggsArcade game and reproduce it in MuggsOfVibes to learn the tool. Turns evaporate at the bell — nothing they build today survives into Tuesday.
• Tue Sep 22: HTML of the student's own game. `/vibes?layer=html`. Six to eight parts, plainly named, placed against each other. Every element visible without CSS.
• Wed Sep 23: CSS. `/vibes?layer=css`. First prompt is Tuesday's Copy-my-turns log pasted as one turn. Then one adjective per element, five to ten turns.
• Thu Sep 24: JavaScript. `/vibes?layer=js`. First prompt is Tuesday + Wednesday pasted as one turn. Then one working behavior — every verb with a when-clause.
• Fri Sep 25: Ship the proto-spec. Full three-day log pasted as one giant opening turn to confirm the game. Then compress to one paragraph; paste into a fresh session; iterate until the game returns; submit the paragraph.
• MuggsOfVibes holds no memory across sessions (Sean, 17 Sep). Coupon tracks turns/tokens only. Copy my turns is the escape hatch. Teacher issues fresh coupons on demand at /vibes/teacher.

Study Guide Week — three days to turn the course-to-date into a printed, 2-page, midterm-ready guide. Mon draft (chunk course content, prompt the model, produce first-draft sections for every topic). Tue audit (check every claim against source, re-prompt to fix). Wed final (condense to two pages, submit before cutoff — the version submitted by Wed cutoff is what gets printed). Thu the guide sits on the desk with the test. Fri the catch-up day.

• Mon Sep 28: Study Guide Day 1 — Doc 1: Lab 1 (Aug 31 – Sep 14). Read the numbered narrative, strike what you know, chunk what's left into MuggsOfStudy, paste each of 4 chunks into Mon's form.
• Tue Sep 29: Study Guide Day 2 — Doc 2: Three Grammars (Sep 15 – 18). Same loop, fresh doc, fresh tool session, Tue's form.
• Wed Sep 30: Study Guide Day 3 — Doc 3: Proto-Spec (Sep 21 – 25). Same loop, Wed's form. After Wednesday's bell, the three days combined get printed as the midterm guide.
• Thu Oct 1: Q1 Midterm. All multiple choice, open study guide (student's own printed guide only). No exit ticket.
• Fri Oct 2: Catch-up on all missing work. Every classwork form so far embedded as tabs, one slide per week.

Three voices on AI. A builder (Karpathy, who makes the models), a skeptic (Chiang, who thinks about compression and writing), and an outsider (Klein × Winthrop, on what any of this means for school and for you). Students take in each one and respond — no midterm pressure, just absorbing the frames that will shape Q2's project work.

• Mon Oct 5: Karpathy — "Deep Dive into LLMs like ChatGPT" (~60 min). Google Form in Locked Mode on Chromebook. 9 items keyed to the 8 anchor beats from the midterm.
• Tue Oct 6: SUB DAY — paper packet. Ted Chiang's "ChatGPT Is a Blurry JPEG of the Web" (The New Yorker, Feb 2023). Students read the article at /d/chiang on their Chromebook and fill a ~2-sheet paper packet. Sub collects at the bell.
• Wed Oct 7: Klein × Winthrop — "Educating Kids in the Age of A.I." (~68 min). Google Form in Locked Mode. 7 items keyed to 6 listen-for moments across the conversation.
• No separate exit tickets this week — the form responses (Mon/Wed) and packet responses (Tue) ARE the record.

AI as a branch of computer science, then compression: lossless, lossy, and the trade-off.

1. U3-01Decompose an observed website from memory into four structural categories: Project, Structure, Style, Behavior.
2. U3-02Write a specification in language and structural notation alone, with no visual representation.
3. U3-03Reconstruct a peer's specification, drawing only from what is written, having never seen the source.

From compression to the model, from the model to the tool, and then to the parts list.

1. U3-04Evaluate the precision of a specification by comparing it against a stranger's reconstruction, and identify the specific words or omissions that produced each divergence.
2. U3-05Name the gap types that appear: contradiction, ambiguity, undefined behavior, gap.
3. U3-06Enter the tool in vibecode: describe something, watch it appear, refine by talking.
4. U3-07Write a four-panel specification in the tool: Project, Structure, Style, Behavior.
5. U3-08Compile, and read the artifact against what was specified.

• Thu Oct 22: shortened bell schedule.
• Fri Oct 23: paper day, the seven components in order.

From AI to Java. AI reaches people inside programs that people wrote. Java is one of the languages those programs are written in.

Programs Do What They Are Told. A program does exactly what its words and its code say. This week the class reads first Java, writes rules a person can test, and checks what a model wrote and what a change did.

Files, Versions and Errors. A program is a file in a folder, with a history of versions, and a compiler that says exactly where it stopped.

How a Program Reaches the Web. A host stores a site's files, a domain name points to the host, HTTPS protects what travels, and the API key stays on a server. On the bench, Java programs start calling methods.

Using Computers Responsibly. Each day this week stands alone. The passages ask whether a program works, who it works for, and who it can hurt, while Reading 2 and the bench carry Java's decisions.

Reading Java Like the Exam. Programmers reuse code with permission, and the AP exam reads Java one way, so this week we read it that way too and start reviewing October and November with new cases.

Finish Strong. One more review, the final exam, and three days on the bench.