What the Twelve Days App is Really Doing
The Twelve Days of Christmas app generates the song verse for any day you request. Day 3 lists three gifts. Day 7 lists seven — including all six from before. Each verse is cumulative, going back to day 1 every time. That’s not a loop. That’s a cascade.
The app’s core is a JavaScript switch statement with twelve cases and zero break statements. Entering at case 12 falls through to case 11, then case 10, all the way down to case 1. The cumulative structure of the song is modeled by the language feature most beginners are warned to avoid. Deliberate fall-through is not a bug here — it is the architecture.
But to appreciate why the cascade is elegant, you first need to see what a normal switch looks like — one with breaks, one match, one clean exit. This page presents both: the grade-to-class-name lookup first (baseline), the Twelve Days cascade second (payoff).
The two things this page demonstrates are inseparable: whether a switch stops at the first match or cascades through subsequent cases — and how each language makes that choice.
The concept, before any language
SWITCH gradeLevel:
CASE 9: className ← “Freshman”
BREAK ← stops here, exits switch
CASE 10: className ← “Sophomore”
BREAK
DEFAULT: className ← “Unspecified”
SWITCH day:
CASE 3: verse ← verse + “three French hens”
// no break — falls into case 2
CASE 2: verse ← verse + “two turtle doves”
// no break — falls into case 1
CASE 1: verse ← verse + “a partridge”
BREAK ← finally stops
Entering at day 3 executes cases 3, 2, and 1 in sequence, accumulating the verse automatically. The absent break is the entire lesson.
The Same Keyword, Two Intents
Start with the normal switch to build the baseline. Then watch what happens when the breaks disappear.
Break after each case. Matching grade 10 returns “Sophomore” and exits immediately. The remaining cases never run.
// break stops execution after each match
function getClassName(gradeLevel) {
let className;
switch (gradeLevel) {
case 9:
className = "Freshman";
break; // exits the switch
case 10:
className = "Sophomore";
break;
case 11:
className = "Junior";
break;
case 12:
className = "Senior";
break;
default:
className = "Unspecified";
}
return className;
}
console.log(getClassName(10)); // "Sophomore"
console.log(getClassName(8)); // "Unspecified"
// break stops each case cleanly
public class HighSchoolClassDriver {
public static String getClassName(int gradeLevel) {
String className;
switch (gradeLevel) {
case 9:
className = "Freshman";
break;
case 10:
className = "Sophomore";
break;
case 11:
className = "Junior";
break;
case 12:
className = "Senior";
break;
default:
className = "Unspecified";
}
return className;
}
public static void main(String[] args) {
int[] grades = {9, 10, 11, 12, 8};
for (int grade : grades) {
System.out.println("Grade " + grade + " \u2192 " + getClassName(grade));
}
}
}
# match/case — no break needed or possible
# Each case only executes its own block
def get_class_name(grade_level):
match grade_level:
case 9:
return "Freshman"
case 10:
return "Sophomore"
case 11:
return "Junior"
case 12:
return "Senior"
case _: # default
return "Unspecified"
print(get_class_name(10)) # Sophomore
print(get_class_name(8)) # Unspecified
JavaScript and Java fall through by default when break is absent. Python’s match/case refuses to cascade — the same verses must be spelled out explicitly.
// No break = deliberate fall-through
// Entering at day 3 cascades through 2 and 1
function buildVerse(day) {
let verse = "";
switch (day) {
case 3:
verse += "three French hens,\n";
// falls through to case 2
case 2:
verse += "two turtle doves, and\n";
// falls through to case 1
case 1:
verse += (day === 1)
? "a partridge in a pear tree."
: "a partridge in a pear tree!";
break;
default:
return "Day out of range";
}
return verse;
}
// Day 3 produces all three lines:
console.log(buildVerse(3));
// Java fall-through is identical to JS
// JS and Java agree completely on cascade
public class DaysXmasDemoDriver {
public static String buildVerse(int day) {
String verse = "";
switch (day) {
case 3:
verse += "three French hens,\n";
// falls through — no break!
case 2:
verse += "two turtle doves, and\n";
// falls through — no break!
case 1:
verse += (day == 1)
? "a partridge in a pear tree."
: "a partridge in a pear tree!";
break;
default:
return "Day out of range (try 1-3)";
}
return verse;
}
public static void main(String[] args) {
for (int day = 1; day <= 3; day++) {
System.out.println("Day " + day + ":");
System.out.println(buildVerse(day));
System.out.println();
}
}
}
# Python match/case cannot cascade.
# Each case must spell the full verse out.
# "Explicit is better than implicit."
def build_verse(day):
match day:
case 1:
return "a partridge in a pear tree."
case 2:
return (
"two turtle doves, and\n"
"a partridge in a pear tree!"
)
case 3:
return (
"three French hens,\n"
"two turtle doves, and\n"
"a partridge in a pear tree!"
)
case _:
return "Day out of range"
Why Does Each Version Look Different?
The guiding question for every Cross Training page: “What does each version reveal about the language’s personality?”
Fall-through is the default. In JavaScript’s switch, execution falls from one case into the next unless a break explicitly stops it. This was a deliberate design choice: JavaScript inherited its switch semantics from C, where fall-through is the norm. The language trusts the developer to put breaks where they want stops.
This means an absent break is ambiguous: did the developer forget it, or intend it? Convention suggests intentional fall-through should be marked with a comment (“falls through”). Without the comment, a code reviewer cannot tell whether it’s a bug or a feature. JavaScript puts the burden of clarity on the programmer.
The Twelve Days app is the proof that intentional fall-through is not a beginner mistake — it is the most elegant solution for a specific class of accumulator problem.
Java and JavaScript agree completely. Java’s switch falls through by default, inherited from C for the same reasons. The syntax is identical, the semantics are identical. This is one of the few places where Java and JavaScript behave exactly the same way despite being very different languages in most other respects.
Java 14+ introduced the switch expression with arrow syntax (case 9 -> "Freshman";), which does not fall through by design — it is Java acknowledging that most developers most of the time want the no-cascade behavior and want it without writing a break. The traditional switch statement is preserved for the cases (like the Twelve Days) where cascade is the point.
Two switch syntaxes in one language — one cascades, one doesn’t. Java made both official.
Python refuses to cascade — by deliberate design. match/case, introduced in Python 3.10, executes only the matching case block and exits. There is no fall-through. There is no way to opt in. The designers of Python considered fall-through a source of bugs, not a power tool, and simply removed it from the feature.
This is Python’s Zen at the architectural level: “Explicit is better than implicit.” Fall-through behavior is implicit — you get it by omitting something (the break). Python eliminates implicit behavior wherever possible and asks the programmer to say exactly what they mean. To build the Twelve Days in Python, you spell out each cumulative verse explicitly. It is more code. Python says that’s a fair price for clarity.
Whether you agree with that philosophy is less important than being able to articulate what the philosophy is. That articulation is Cross Training.