Three Stooges Driver — Entry Log

Line 6 of the original Java contains System. out.println with a space between System. and out. This was initially flagged as a compile error — but after live testing in JDoodle and CodeHS Sandbox, it turned out to compile and run successfully in both venues. Java’s specification permits whitespace between tokens; the dot . is a separator, and whitespace around separators is legal.

Decision: preserve the space exactly but reframe the teaching moment from “compile error” to style issue. The code runs — but a human reader will do a double-take, a strict linter will flag it, and a code reviewer will ask why it’s there. Removing the space is still a worthwhile first exercise in reading code carefully and following Java conventions.

Purple Rain used a split layout (code left, live canvas right). Three Stooges has no visual output — Java console programs print to stdout, not to a pixel canvas. The showcase card uses full-width code display. This is the correct layout for all future Java-only Tool Time entries.

Target 1: public static void main(String[] args) — explained word-by-word in the Your Turn section. Students are given both the explanation and a suggested AI prompt to explore it further.

Target 2: ArrayList without duplicates — the no-duplicate pattern using contains() before add() is shown in a code block. Students are challenged to extend the Stooges list, add Shemp, then add a Scanner for keyboard input.

Two Stooges movie clip links in the Your Turn section: the TNT Legacy Thanksgiving page (features Stooges comedy clips) and “Swingin’ the Alphabet” (Stooges doing a nested-loop algorithm set to music). Both links open in a new tab since they are on separate pages in the TNT ecosystem.

The original entry icon was 🥟 — which renders as 🥟, a dumpling. Completely wrong for the Three Stooges. The code point was off by one character during entry. This is a good reminder to always preview emoji characters; Unicode code points are not memorable and a single digit difference produces a wildly different glyph.

The theater masks emoji 🎭 🎭 is the perfect replacement: the Stooges are a theatrical comedy troupe with roots in vaudeville, and the comedy/tragedy masks are the universal symbol of theatrical performance. The emoji reads immediately as “performance,” which is exactly what Tool Time entries celebrate.

Lesson: When pasting Unicode code points by hand, verify the rendered glyph immediately. The character preview in VS Code’s hover tooltip is the fastest way to avoid deploying a dumpling when you meant a theater mask.

This is a classic CSS centering trap. The hero uses two different centering mechanisms that serve different purposes, and the fix requires both:

/* BEFORE — hero-content left-shifted despite text-align: center */
.hero-content {
    text-align: center;   /* centers inline content (text, icons) WITHIN block */
    max-width: 760px;     /* ← constrained width, but block itself was left-aligned */
}

/* AFTER — one line added */
.hero-content {
    text-align: center;
    max-width: 760px;
    margin: 0 auto;       /* centers the BLOCK ITSELF within its parent */
}

Why it looked left-shifted: #hero is a flex container with justify-content: center — this centers Bootstrap’s .container (which is full-width). But inside the container, .hero-content has max-width: 760px. Without margin: 0 auto, that narrower block defaults to left-alignment within the container. The text inside was centered (via text-align), but the content block itself was hugging the left edge.

The teachable pattern:

• text-align: center — centers inline content (text, icons) within a block element.
• margin: 0 auto — centers the block element itself within its parent container.

Both threeStoogesOriginalStyles.css and threeStoogesChatlogStyles.css were updated simultaneously since the chatlog hero uses the same pattern.

Live testing in JDoodle and CodeHS Sandbox confirmed: System. out.println with the space runs without error. This required updating the narrative in both the entry page and this chatlog.

Why it compiles: Java’s specification defines whitespace as a token separator, and the dot . is itself a separator token. Whitespace between tokens is permitted by the grammar — so System . out . println ( … ) is legal Java. Modern compilers (including those used by JDoodle and CodeHS) follow this correctly. Older or stricter tools might warn, but they should still compile it.

Why it’s still worth noting: Legality and good practice are not the same thing. The space will confuse any human reader, will be flagged by style linters (e.g., Checkstyle), and signals that the author either didn’t notice it or didn’t care. The teaching value shifts from “find the bug before it bites you” to “read code like a professional — a reviewer will ask about this.”

Changes made: The red warning box in the entry page was reworded from “Compile Error” to “Style Issue,” the icon changed from a bug 🐛 to an eye 👁️, and the text was updated to reflect that JDoodle/CodeHS will run it. The Session 1 design-decision box and the prompt critique were updated to match. The attr-strip no longer says “space bug.”

Stage 1 — JDoodle works as-is

The original code uses args[0], args[1], args[2]. JDoodle has an “Input arguments” field. Students type Moe Larry Curly into it and the code runs immediately — no changes needed. This validates the design: the command-line args pattern is intact and real. First lesson: read the tool’s interface before assuming something won’t work.

Stage 2 — What if there’s no args field?

In many classroom environments (certain IDEs, web-based sandboxes, AP Classroom), there is no way to pass command-line arguments. Running the code as-is throws an ArrayIndexOutOfBoundsException — a crash, not a compile error. The AI challenge: “Add a fallback so the program uses hardcoded names if args.length < 3, and command-line names if they are provided.” Students learn defensive programming and the args.length check in one step.

Stage 3 — Bridge args[] into an ArrayList + three levels of printing

Keep args[] exactly as it is. Create an empty ArrayList<String> and populate it with a for-each loop over args. Then add Shemp manually. After that, print both structures and compare: println(args) produces a memory address like [Ljava.lang.String;@6d06d69c because Java arrays do not override toString(). println(stooges) produces [Moe, Larry, Curly, Shemp] because ArrayList does override toString(). A printArrayList() static method with an indexed for-loop then gives full control: one name per line, numbered. Three print strategies, three different results, one important lesson about what toString() does and why it matters.

Stage 4 — Prevent duplicates

Now that we have an ArrayList, try adding Moe twice. The list allows it: [Moe, Larry, Curly, Moe]. There is only one Moe. The fix: check !list.contains(name) before each list.add(name). Simple, clean, introduces one of the most important ArrayList patterns in APCS. The AI challenge: “Add a no-duplicate guard using .contains() and print a message if the name was rejected.”

Stage 5 — Case sensitivity

Now try adding "moe" (lowercase). .contains("moe") returns false because Java’s String.equals() is case-sensitive. "Moe" and "moe" are different strings. The duplicate guard fails. The AI challenge: “Normalize all stooge names to title case before checking and adding, so ‘MOE’ and ‘moe’ are both treated as ‘Moe’.” Introduces toLowerCase(), toUpperCase(), and the concept of normalization.

• Stage 6: ArrayIndexOutOfBoundsException anatomy. When Stage 2’s args crash fires, students see a stack trace for the first time. Reading a stack trace is a fundamental skill. Ask AI: “Explain the stack trace I got. What is line number telling me? What is ArrayIndexOutOfBoundsException?”
• Stage 7: Sorting the roster. Once the list has five Stooges, ask AI to sort it alphabetically. Introduces Collections.sort() and the concept that an ArrayList isn’t ordered by default.
• Stage 8: Enhanced for-each vs indexed loop. Printing the list with for (String s : stooges) vs for (int i = 0; i < stooges.size(); i++). When would you use each? What if you need the index?
• Stage 9: Build a Stooge class. Each Stooge has a name and a specialty (Moe — boss/slapper; Larry — victim; Curly — nyuk nyuk). An ArrayList<Stooge> replaces ArrayList<String>. Generics, toString() override, object-oriented thinking. The full APCS journey from primitive to OOP in one exercise.

The validator did report three errors, and KLP correctly diagnosed the pattern (one malformed character cascading into multiple errors). The actual culprit was not a bare < but a semicolon inside a closing tag:

<!-- Wrong: -->
<code>"Moe"</code;   ← semicolon inside the tag name

<!-- Fixed: -->
<code>"Moe"</code>  ← proper closing tag

The HTML parser sees </code; as an end tag with the name code; — which does not exist. This produces a cascade of three validation errors:

1. End tag </code;> is not a valid tag name.
2. The unclosed <code> is still considered open.
3. The text “ are all treated the same” after the semicolon now parses in an unexpected context.

The DWR lesson: One misplaced character inside a tag can cascade into several validator errors that all look unrelated. When the validator flags multiple errors close together, look for a single malformed tag at the top of the cluster — fixing it often clears all of them at once. In this case, the semicolon crept in when rapidly typing the closing </code> tag next to a sentence that ended with a semicolon in the source text.

The .lang-idea-strip chips were all <span> elements. Converting the new Stooge Antics entry to an <a class="lang-idea"> anchor provides the link behavior without any visual change to the chip itself. The anchor inherits all the existing .lang-idea padding, border, and color rules.

Two CSS rules were added to threeStoogesOriginalStyles.css to handle the anchor-specific behavior: text-decoration: none (so the chip doesn’t show an underline) and a hover transition that deepens the sepia background and shifts text to cream — matching the interactive feel of other sepia-toned links on the page.

The fa-film icon was chosen as it is already used in the same .your-turn-card section (“Need Stooge inspiration?” paragraph), making the visual language consistent. target="_blank" rel="noopener noreferrer" follows the page’s existing convention for all cross-section links.

Path resolved: _LegacyTNT/movie_clips/stoogeTurkey.html from root → ../../_LegacyTNT/movie_clips/stoogeTurkey.html relative to ToolTime/StoogesDriverJava/.

The link was moved from the .lang-idea-strip inside the .your-turn-card to the .st-back-bar immediately below the main navbar — the persistent navigation strip that holds Tool Time Home and Entry Chatlog. It now sits as a third link inside the same inner div that wraps those two anchors, separated by the same gap: 1.25rem spacing.

The back bar’s existing .st-back-bar a rule already applies color: var(--st-sepia) and a hover transition to cream, so no additional CSS was needed. The two a.lang-idea rules added in Session 6a were removed as dead code.

Why the back bar is the better home: The back bar is visible at every scroll position on the page (it sits just below the sticky navbar). A novice who arrives and immediately wonders “who are these people?” can find the clip link before reading a single paragraph. The .lang-idea-strip is useful as a topic-idea prompt, not as a navigation anchor — a clickable external link belongs in the navigation layer, not the content layer.