Using Sport-Specific State-Based Mental Models to Scaffold Introductory Java Learning for Student-Athletes: A Wrestling-Inspired Conceptual and Pedagogical Framework

Abstract

Introductory Java programming requires learners to reason about abstract computational concepts such as program state, control flow, and execution order, which often present substantial difficulties for novice programmers. These challenges may be further intensified for collegiate student athletes when programming instruction remains disconnected from the domain knowledge that shapes their prior experiences. This paper proposes a wrestling-inspired, state-based pedagogical framework that leverages the rule system of National Collegiate Athletic Association (NCAA) wrestling as an analogical knowledge domain for introducing foundational Java programming concepts. Within this framework, wrestling match states and scoring actions are systematically mapped to core programming constructs, which include variable assignment, conditional branching, loops, method invocation, and program termination. This paper is positioned as a conceptual and pedagogical framework study rather than an empirical intervention study. It focuses on the theoretical rationale, conceptual alignment, instructional mappings, and classroom implementation possibilities of a wrestling-inspired approach. This paper does not report participant data, learning assessments, or comparative outcome measures. Instead, it illustrates how sport-specific mental models can be transformed into structured instructional representations that may support learners’ reasoning about program execution. By integrating domain-aligned cognitive schemas with programming instruction, the proposed framework offers a structured knowledge scaffolding approach that is designed to support novice understanding of computational processes in introductory programming education.

1. Introduction

Introductory programming courses are widely recognized as cognitively demanding for novice learners, particularly due to their reliance on abstract constructs such as variable state, control flow, and method execution. Prior studies consistently report that students struggle to develop accurate mental models of program behavior, which in turn hampers their ability to reason about execution flow, state changes, and debugging tasks [1,2,3]. These challenges are especially prominent in introductory Java courses, where multiple layers of abstraction are introduced early and concurrently.

For collegiate student athletes, these cognitive difficulties are often amplified by contextual and motivational factors. Student-athletes typically operate under highly structured schedules shaped by training, competition, and travel, which leave limited time and cognitive resources for demanding academic subjects [4]. At the same time, many student-athletes demonstrate strong discipline, adherence to rules, and sustained engagement within sport-specific domains while showing comparatively lower engagement in non-sport academic areas such as computer programming. This imbalance does not necessarily reflect a lack of ability but instead indicates a misalignment between students’ primary domain of motivation and the instructional context of programming courses.

Research in learning sciences emphasizes that motivation, identity, and prior knowledge play a central role in how learners allocate attention and effort across domains [4,5]. When instructional content is perceived as disconnected from learners’ existing interests or identities, engagement may remain shallow even among highly disciplined students. Conversely, instruction that aligns with learners’ prior experiences and domain identities may promote deeper engagement and more effective conceptual transfer [5,6].

Mental models’ theory provides a strong theoretical foundation for addressing both the cognitive and motivational challenges faced by student-athletes in programming education. According to Johnson-Laird, learners reason about complex systems by constructing internal representations that capture the structure and dynamics of those systems [7]. In programming education, the quality of these mental models directly influences learners’ understanding of control flow, method invocation, and state transitions [2,3]. Importantly, mental models are shaped by learners’ existing domain knowledge, which suggests that instruction grounded in familiar, well-internalized domains may facilitate both comprehension and engagement.

Analogical and embodied learning research further supports this approach. Structure-mapping theory explains how learners transfer relational structure from a familiar base domain to a novel target domain through analogy [6]. Empirical studies in Science, Technology, Engineering, and Mathematics (STEM) education demonstrate that well-designed analogies can reduce cognitive load and support abstraction by anchoring new concepts in familiar experiential contexts [6,8]. In computer science education, analogy-based instruction and visualization techniques have been shown to improve novice learners’ understanding of program execution and dynamic behavior [9,10].

In the present framework, structure-mapping theory serves as the primary design logic for constructing the wrestling-to-Java mappings. Specifically, NCAA wrestling functions as the familiar source domain, while introductory Java programming functions as the target domain. The proposed mappings are developed by identifying relational correspondences between the two domains such as state transition, control transfer, conditional evaluation, interruption, and termination. Mental model theory and embodied learning provide complementary perspectives by explaining why familiar sport-specific representations may help learners reason about abstract program execution.

Building on these insights, this paper proposes a state-based pedagogical framework grounded in National Collegiate Athletic Association (NCAA) wrestling rules for teaching introductory Java to collegiate student-athletes. In this study, a state-based pedagogical framework refers to an instructional design that organizes programming concepts around states, state changes, and rule-governed transitions. Rather than introducing Java program constructs as isolated syntax, the framework presents variables, conditionals, loops, methods, exceptions, and termination as components of an execution system in which program state is created, evaluated, updated, interrupted, and completed. NCAA wrestling is used as the analogical source domain because it is a rule-governed activity organized around visible match states, control transitions, scoring actions, interruptions, and outcomes. These characteristics closely parallel fundamental programming abstractions including program state, control flow, method execution, exception handling, and program termination. Because student-athletes may possess deeply internalized mental models of wrestling through years of training and competition, this domain provides a meaningful foundation for analogical reasoning in introductory Java instruction.

The objective of this study is to design a conceptual and pedagogical framework that systematically maps match-level wrestling states such as Neutral, Top, Bottom, and Reset to key concepts in Java program execution which includes initialization, execution context, control transfer, and termination. It also aligns wrestling scoring actions including Takedown, Escape, Reversal, and Near Fall with fundamental Java statements and control structures. Instead of evaluating learning outcomes empirically, this work adopts a conceptual and pedagogical framework approach grounded primarily in structure-mapping theory. The framework identifies relational correspondences between NCAA wrestling as the source domain and introductory Java programming as the target domain, with emphasis on instructional structure, conceptual alignment, analogical reasoning, and classroom applicability.

Accordingly, the present study is framed as a conceptual and pedagogical framework paper rather than an empirical intervention study. It does not include participants, classroom implementation data, learning assessments, or comparison with traditional instruction. Instead, its contribution lies in the theoretical justification, systematic instructional mapping, and classroom-oriented design of a wrestling-inspired approach to introductory Java learning.

This paper makes three primary contributions:

• A conceptual match-level state mapping, referring to the alignment between broad wrestling match positions such as Neutral, Top, Bottom, and Reset and key Java program execution concepts such as initialization, execution context, control transfer, and termination. This mapping provides a theoretically grounded instructional representation for reasoning about program control and execution.
• A systematic action-level mapping between wrestling scoring actions and fundamental Java statements is designed to support analogical transfer from sport-specific rules to programming constructs.
• A set of practical instructional artifacts including mapping tables, revised Java code examples, classroom talk scripts, and embodied activity suggestions can be adapted for introductory Java instruction with student-athletes.

By intentionally leveraging student-athletes’ existing passion for competitive sport, discipline, and rule-based reasoning, the proposed framework positions athletic engagement as a cognitive and motivational resource within computer programming education.

2. Related Work

Understanding novice programmers’ cognitive processes has been a major focus in computer science education research. Studies have shown that students frequently struggle with the dynamic aspects of programming including state changes, control flow, and method invocation [3,11]. Mental model theory suggests that learners form internal representations to reason about complex systems, and the quality of these representations is critical for debugging and program comprehension [12,13]. Prior work highlights that inadequate mental models lead to common misconceptions in beginner programmers, emphasizing the need for instructional scaffolds that explicitly map program behaviors to observable concepts [14].

Analogical and embodied learning approaches have been widely employed to address these cognitive challenges. Gentner’s structure-mapping theory provides a formal framework for transferring relational structures from a familiar domain to a novel target domain, supporting conceptual transfer [15]. Empirical research demonstrates that learners benefit from analogies that align with their prior experiences, enabling faster abstraction and reduced cognitive load [16,17]. Embodied cognition studies further suggest that sensorimotor engagement can reinforce conceptual understanding and retention, particularly for abstract STEM concepts [18]. In computer science education, visualizations, role-playing, and interactive simulations have been shown to improve comprehension of program execution, control flow, and state management [16,19].

Research on domain-specific cognitive scaffolding has emphasized the importance of aligning instructional design with learners’ existing knowledge and identity. For instance, studies on student-athletes reveal that structured routines, discipline, and highly internalized domain knowledge in sports can be leveraged to enhance engagement in academic tasks when instructional content is appropriately contextualized [17,20]. Prior work in STEM education indicates that using familiar, rule-governed domains can provide natural analogies for abstract programming concepts, reducing cognitive load while increasing motivation [21].

Visualization and interactive tools have emerged as critical support for novice learners, offering concrete representations of otherwise invisible program behaviors. Tools such as algorithm animation environments and web-based program visualizers enable students to observe state changes and method execution in real time, which has been shown to improve both understanding and transfer of knowledge to new problems [22,23]. These studies collectively suggest that instructional designs which integrate analogical reasoning, embodied cognition, and observable feedback mechanisms can scaffold complex cognitive processes in computer science education.

The present work extends these insights by proposing a sport-specific mental model by using NCAA wrestling as the source domain for analogical transfer to introductory Java. Unlike general visualizations or abstract analogies, this approach leverages student-athletes’ deeply internalized understanding of wrestling positions, control transitions, and scoring actions to create a coherent, identity-aligned mental model of program state, control flow, and method execution. This framework operationalizes principles from mental model theory, analogical reasoning, and embodied cognition, which provides a novel approach to teaching programming to a specialized population.

3. NCAA Wrestling Rule Overview

In order to justify the selection of collegiate wrestling as an instructional source domain for introductory Java programming, it is necessary to characterize aspects of NCAA wrestling that yield structured, rule governed state transitions and observable, discrete events. Such structural properties are essential to the proposed framework because they parallel the state changes, control flows, and method invocations that underline program execution. This section outlines the relevant components of NCAA wrestling rules which focus on match-level states and scoring actions and highlights why these components are pedagogically meaningful in comparison to programming abstractions.

3.1. Selection Criteria for Wrestling States and Actions

The framework selects wrestling states and scoring actions according to four criteria. First, each selected state or action is formally defined in NCAA wrestling rules and is familiar to collegiate wrestlers through repeated training and competition. Second, it involves a clear state, transition, condition, interruption, or outcome that can be compared with Java program execution. Third, it has sufficient pedagogical relevance to foundational Java topics, including variables, conditionals, loops, methods, exceptions, and termination. Fourth, it is simple enough to support introductory instruction without requiring excessive wrestling-specific detail. Based on these criteria, the framework focuses on match-level states such as Neutral, Top, Bottom, and Reset, and scoring or control actions such as Takedown, Escape, Reversal, Near Fall, Riding Time, and Pin.

3.2. Match-Level States

Collegiate wrestling matches are governed by a formal state space defined by a limited set of exclusive positional states, each of which constrains the set of allowable actions and influences subsequent transitions. The official NCAA Wrestling Rules Book [24] specifies states and restart conditions that are consistently applied across all sanctioned competition, ensuring that student-athletes internalize these structures through repetitive exposure and competitive experience. The most salient match-level states for instructional mapping are:

• Neutral: A position in which neither competitor has established control. Athletes may engage in takedown attempts, defensive maneuvers, or strategic positioning. The Neutral state is analogous to the initial state of a program where no control context has been established.
• Top: A control position in which one wrestler has dominion over the opponent’s movement. Establishing the Top position typically follows a scoring action such as a takedown or reversal. In programming terms, this is analogous to a calling context that dictates control flow.
• Bottom: A subordinate position in which the controlled wrestler must attempt either an escape or a reversal to regain agency. This position can be interpreted analogically as a nested or subordinate execution context such as within a method or block that cannot independently alter the overall program flow.
• Reset: a state that occurs when referees suspend the match because of boundary violations, stalemate conditions, or safety considerations and restart action from a neutral or otherwise specified position. This externally imposed reset is conceptually similar to runtime reinitialization or scope reset in program execution, where control returns to a known and standardized state.

The competitive structure of NCAA wrestling thus embodies a finite-state system in which transitions are strictly regulated by rules and adjudicated by referees. These structural properties support the hypothesis that wrestlers develop stable mental representations of state and transition, making the sport domain a promising base for analogical transfer.

3.3. Scoring Actions

In addition to defining match states, NCAA rules prescribe a discrete set of scoring actions that correspond to changes in control, advantage, or match outcome. Each action is associated with explicit conditions and quantifiable outcomes, illustrating how rule-based criteria generate state transitions and scoring consequences [24]. The actions selected for pedagogical mapping in this study include:

• Takedown: Awarded when a wrestler gains control from a neutral position. Scoring and state transition criteria for takedowns are unambiguous in the official rules and signify a movement from Neutral to Top control. This action is analogous to an assignment or initial state establishment in programming.
• Escape: Given when a bottom wrestler successfully breaks the opponent’s control and returns to Neutral. This action represents restoration of autonomy without reversal of hierarchical control, similar to a function return that relinquishes local control back to the caller.
• Reversal: Rewarded when a wrestler transitions from bottom control to top control. The reversal action embodies both an escape and a new establishment of control, akin to an operation that both exits a subordinate context and modifies global state.
• Near Fall: Occurs when a controlling wrestler turns the opponent’s back toward the mat for a specified duration, resulting in incremental scoring. The duration-based criteria introduce a conditional temporal aspect that is comparable to conditional evaluation and nested control flow in programs.
• Riding Time: Points awarded at the end of the match to the wrestler who has accumulated more control time over the opponent. This aggregate measure reflects persistent control and can be likened to state persistence across multiple execution paths.
• Pin (Fall): A terminal condition in which both of the opponent’s shoulders are held in contact with the mat for the required duration. Under NCAA scoring rules, a fall ends the match immediately, which is analogous to program termination upon reaching a halting condition.

These scoring actions as defined in the official NCAA rules provide a discrete event space that can be systematically mapped to programming constructs such as assignment, branching, repetition, method invocation, and termination conditions. The specificity and enforceability of the rules ensure that student-athletes internalize the causal relationships between actions and state transitions, making these patterns useful for instructional analogies.

3.4. Instructional Relevance

Part of the rationale for selecting NCAA wrestling as a source domain for pedagogical mapping lies in the rule clarity, state visibility, and participant familiarity inherent in the sport. Unlike many informal analogies that may lack structural precision, NCAA wrestling rules provide:

• A finite set of states with well-defined entry and exit conditions, corresponding to well-structured control contexts in programming.
• Rule-governed transitions that are enforced uniformly by referees, which parallels the deterministic control flow enforced by programming language semantics.
• Observable outcomes and scoring that serve as external feedback, similar to program output or state traces visible to learners.

By leveraging these domain characteristics, the framework proposed in this paper uses students’ existing mental representations of wrestling to scaffold the learning of abstract programming concepts. The detailed mappings presented in Section 3 build on the overview provided above.

4. Wrestling-Inspired State-Based Java Teaching Framework

This section clarifies the instructional design logic underlying the proposed mappings. The framework aligns key conceptual challenges in introductory Java learning including program state, control flow, loops, methods, and termination, with structurally comparable features of NCAA wrestling such as match states, rule-governed transitions, scoring actions, interruptions, and terminal outcomes. These mappings are grounded in analogical reasoning and are based on relational correspondence rather than surface similarity. They are then translated into instructional examples, code snippets, guiding questions, and embodied classroom activities.

4.1. State Creation and Update Through Wrestling-Inspired Mental Models

A persistent difficulty in introductory Java education lies in students’ incomplete understanding of how program state is created, controlled, and updated during execution. Novice learners frequently conflate variable existence with value assignment, which misunderstand reassignment semantics, or fail to recognize when prior state has been discarded. These misconceptions indicate fragile mental models of state manipulation rather than syntactic deficiency.

To address this issue for collegiate student-athletes, this work proposes sport-specific, state-based mapping that aligns fundamental wrestling actions with Java statements responsible for state creation and update. Wrestling scoring actions are governed by explicit rules concerning control acquisition, loss, and transfer, which makes them particularly well suited for modeling program state transitions. Because student-athletes possess deeply internalized and operationalized knowledge of these actions, the mappings aim to leverage existing domain expertise to support accurate reasoning about Java state semantics.

Table 1. Mapping Wrestling Scoring and Match Actions to Fundamental Java State Operations.

Wrestling Action	Athlete’s Meaning	Java Statement	Teaching Interpretation
Neutral start	No control yet	Variable declaration	State exists but is unassigned
Takedown	First control	Assignment (=)	Program gains control over state
Reversal	Control switches	Reassignment	Ownership of state changes

summarizes the proposed mappings between wrestling actions, their athletic meaning, corresponding Java statements, and their instructional interpretation.

4.1.1. Neutral Start and Variable Declaration

In NCAA wrestling, the Neutral position represents a formally defined match state in which both athletes are present, active, and positioned to initiate action without established control. It constitutes a rule-governed condition of readiness in which potential scoring actions exist but become permissible only after control is achieved. This concept closely parallels variable declaration in Java. When a variable is declared, memory is allocated and the variable becomes part of the program’s state space, even though no meaningful value has been assigned and no computation has been performed. At this stage, the variable participates in program execution structurally, but it does not yet exert influence over computational outcomes.

Instructionally, this mapping emphasizes that declaration establishes existence rather than control. By aligning variable declaration with the Neutral position, the framework is designed to address a common novice misconception that declared variables “do nothing” until assigned. Instead, declaration is reframed as a legitimate, preparatory, and rule-defined state within the program execution process. This perspective encourages learners to distinguish between the existence of state and the control of state, a distinction that is foundational for understanding variable initialization, execution order, and subsequent state transitions.

4.1.2. Takedown and Assignment

In wrestling, a takedown represents the first rule-defined transition in which one athlete establishes control over the opponent, which shifts the match from a Neutral state into a controlled position. This action is discrete, rule-defined, and consequential for scoring and subsequent match flow. In Java, assignment serves a similar conceptual function by establishing the program’s first authoritative control over a variable’s state.

From an instructional perspective, assignment is framed not merely as placing a value into a variable, but as an act of control acquisition. The emphasis is placed on the semantic consequence of assignment: the variable now participates actively in computation and decision-making. This mapping shifts student attention away from surface-level value manipulation toward a deeper understanding of how assignment transforms the program state from passive existence into operational relevance.

4.1.3. Reversal and Reassignment

In wrestling, a reversal occurs when control shifts from one athlete to the other during continuous engagement. Importantly, a reversal does not interrupt or reset the match; instead, it preserves the ongoing competitive state while transferring dominance. The match context, participants, and accumulated actions remain intact, even as control changes hands. This structure closely corresponds to reassignment in Java. During reassignment, a variable maintains its identity and scope while its value is updated as program execution progresses. No new variable is created, and execution continues within the same control context. In both cases, control is not eliminated or restarted but dynamically transferred within an existing state. To make this correspondence concrete, consider the following illustrative Java fragments:

int score = 2;     // initial control
score = score + 2; // reassignment

Reassignment does not eliminate the variable score; it merely updates its value. The new value is explicitly derived from the existing state. The execution context remains continuous, and the variable’s identity and scope are preserved. What changes is the dominance over the represented state: the program transitions from one configuration of control to another by leveraging the current value instead of discarding it. This execution exhibits the same underlying control-preserving transition as a wrestling reversal. A bottom-position athlete transitions into control by leveraging the existing engagement. Similarly, the reassignment operation builds upon the current state of a variable to establish a new value. In both cases, the transition is internally generated and dependent on the current context rather than imposed through an external reset or restart.

Mapping reversal to reassignment foregrounds reassignment as a control transition rather than a state re-creation. This pedagogical framing directly addresses a well-documented novice misconception in programming education, which is namely the tendency to interpret reassignment as the creation of a new variable instance. By reasoning about reassignment as a form of dominance shift over an existing state, students are encouraged to develop a more coherent mental model of variable mutability, execution continuity, and state ownership in Java programs.

4.2. Conditions and Decisions: Wrestling near Fall and Java Control Flow

Table 2. Mapping between Wrestling Near-Fall Situations and Java Conditional Constructs.

Wrestling Action	Athlete’s Meaning	Java Statement	Teaching Interpretation
Near fall (two seconds)	A scoring opportunity exists but the outcome is not yet determined	if statement	When a condition is satisfied, a specific action is executed
Extended near fall	Sustained scoring pressure with alternative outcomes	if–else statement	Different execution paths occur depending on the condition

presents a structured overview of the correspondence between wrestling near-fall situations and fundamental Java conditional constructs. Each row defines a semantically coherent mapping that links a rule-governed wrestling scenario with a specific programmatic construct in Java. The table functions as a cognitive anchor that enables student-athletes to draw on their embodied understanding of match dynamics when reasoning about control flow and branching behavior in programs. Subsequent subsections elaborate on each mapping through semantic justification, illustrative Java code, and pedagogical interpretation.

4.2.1. Near Fall and Conditional Execution (if)

In NCAA wrestling, a near fall represents a potentially decisive situation in which an athlete exposes the opponent’s back at a legally defined angle. However, scoring is contingent upon whether the exposure satisfies rule-based temporal and positional criteria as determined by the referee. Points are awarded only when the specified conditions are satisfied; otherwise, the score remains unchanged and play continues. This rule structure corresponds directly to the semantics of the Java if statement. An if statement authorizes execution based on the evaluation of a Boolean expression and does not initiate action independently. The statements within the if block execute only when the condition evaluates to true.

int exposureTime = 2;
int score = 0;
if (exposureTime >= 2 && exposureTime < 3) {
     score += 2;
}

Theif statement evaluates a Boolean condition before deciding whether to execute the following block of code. In the above example, if (exposureTime >= 2 && exposureTime < 3) checks whether the exposure time meets the minimum requirement for a near fall. This scenario illustrates a conditional reward system: points are granted only when the athlete meets the specified performance criterion, which is similar to how a referee evaluates adherence to technical requirements. Students can understand that an if statement is a rule check, not an action by itself. It governs whether a particular piece of code will run, which is similar to how a wrestling rule determines whether a near fall earns points. This helps learners avoid the common misconception that if automatically performs an action, instead reinforcing that it is a conditional gate controlling program behavior.

Pedagogically, this mapping helps students reconceptualize if statements as rule checks rather than action triggers. By aligning if with near fall evaluation, learners understand that conditions govern whether an action may occur, not how the action is performed. This framing counteracts the novice tendency to treat conditional statements as procedural steps instead of evaluative gates within program execution.

4.2.2. Extended near Fall and Branching Decisions if–else

Following a near fall, the scoring outcome is determined by the temporal duration and stability of control. Each episode produces a single, exclusive score, which reflects the principle that extended control is associated with greater reward, while shorter control corresponds to lesser reward. This logic maps naturally onto Java’s if–else construct, which enforces exclusive branching based on a Boolean condition. The if–else structure represents a mutually exclusive decision process in which only one conditional branch may be executed during a single pass of program execution. The conditions are evaluated sequentially from top to bottom. Once a condition evaluates to true, control transfers to the corresponding block and subsequent branches are not evaluated.

int exposureTime = 3;
int score = 0;
if (exposureTime < 4 && exposureTime >= 3) {
    score += 3;
} else if (exposureTime < 3 && exposureTime >= 2){
    score += 2;
}
		  

In the above example, the first condition checks whether exposureTime falls within the range required for a higher value near fall. If this condition is satisfied, three points are awarded, and the program does not evaluate the subsequent condition. If the first condition is not satisfied, the else if branch is evaluated to determine whether a lower scoring condition applies. From the perspective of wrestling rules, this structure parallels the evaluation of near-fall scoring by referees. Extended and dominant exposure warrants a higher score and thereby excludes lower scoring outcomes. The lower threshold is evaluated only in cases where the higher threshold is not met. At no point do the two scoring conditions apply concurrently.

From a pedagogical perspective, this mapping highlights that if–else statements represent rule-based prioritization rather than independent checks. Students learn that if–else encodes an ordered decision logic, where conditions represent hierarchical thresholds rather than parallel evaluations. This framing helps learners distinguish if–else from multiple standalone if statements and supports accurate reasoning about exclusive control flow in Java programs.

4.3. Control Flow and Iterative Execution: Wrestling-Inspired Analogies for Teaching Java Loops

Beyond state creation and conditional decision-making, effective programming also requires learners to reason about the dynamics of control flow, which includes the duration of program control, the conditions under which actions repeat, and the mechanisms through which execution may be interrupted or redirected. These aspects of program execution are particularly challenging for novice programmers, who frequently struggle to conceptualize repetition, early termination, and partial iteration within loop constructs.

Wrestling provides a highly structured and embodied model for understanding program execution and control flow. Concepts such as riding, referee stoppages, and brief resets encode explicit rules governing how long control persists, when actions repeat, and when execution must pause, terminate, or resume. These rule-governed transitions closely parallel the mechanisms that regulate repetition and interruption in programming. To extend the analogy from individual scoring actions to sustained control situations,

Table 3. Mapping Wrestling Control Actions to Java Control Flow Statements.

Wrestling Action	Athlete’s Meaning	Java Statement	Teaching Interpretation
Riding	Maintaining control	while	Repeat while condition holds
Referee breaks action	Forced stop	break	Immediate exit from loop
Temporary pause	Brief reset	continue	Skip current iteration

summarizes how wrestling control actions correspond to Java control flow statements.

4.3.1. Riding and while

In wrestling, riding refers to a situation in which one athlete maintains control over the opponent for a sustained period. The action continues only while this control is preserved. The defining characteristic of riding is persistence under an ongoing condition: the action remains active as long as the control condition is maintained. This structure closely corresponds to the semantics of the Java while loop, in which program execution continues as long as a specified condition evaluates to true.

boolean ridingCondition = true;
int controlTime = 0;
while (ridingCondition) {
    ridingCondition = checkRidingCondition();
    if (!ridingCondition) {
        break;
    }
    controlTime++;
}
		  

This loop represents the Riding phase in wrestling, where one athlete maintains continuous control over the opponent. In the while loop, the variable ridingCondition represents the ongoing control state. At the beginning of each iteration, the program re-evaluates this condition through checkRidingCondition(). If the riding condition no longer holds, ridingCondition becomes false, and the break statement immediately exits the loop. If the condition remains valid, controlTime increases by one, representing the continued accumulation of riding time.

Importantly, the duration of the loop is not predetermined. Instead, loop execution persists only as long as the riding condition remains valid. In wrestling, a riding situation may end when the opponent escapes, a reversal occurs, or the referee stops the action. Similarly, in the program, the loop terminates when ridingCondition evaluates to false. This conditional persistence mirrors the rule-governed nature of control maintenance in wrestling.

By mapping the concept of riding to a while loop, learners can conceptualize loop execution as a state-dependent continuation rather than as a fixed number of repetitions. Loop persistence depends on the repeated evaluation and maintenance of a controlling condition, which parallels how riding depends on sustained dominance in wrestling. This analogy is designed to help student-athletes use their existing domain knowledge to reason about conditional iteration in introductory Java programming.

4.3.2. Referee Stoppage and the break Statement

While the Riding analogy illustrates how program execution may persist under a maintained condition, wrestling also provides a model for understanding how execution can be terminated abruptly by an external rule. In a wrestling match, the referee may halt the action immediately when a dangerous or illegal situation is detected. This interruption overrides the ongoing flow of the match regardless of the athletes’ current positions or the progression of the sequence. Such an authoritative interruption corresponds directly to the semantics of the Java break statement.

boolean ridingCondition = true;
int controlTime = 0;
while (ridingCondition) {
    controlTime++;
    boolean dangerousPositionDetected = checkDangerousPosition();
    if (dangerousPositionDetected) {
        break;
    }
    ridingCondition = checkRidingCondition();
}
		  

In this program, the while loop represents continuous engagement similar to live wrestling, where the action persists while the riding condition remains active. The variable ridingCondition models the ongoing state of control, while controlTime records the duration of the engagement. During each iteration, controlTime increases by one to represent the continued accumulation of control time. The statement checkDangerousPosition() evaluates whether a dangerous position has emerged during the current moment of engagement. If dangerousPositionDetected evaluates to true, the break statement immediately exits the loop. If no dangerous position is detected, the program then re-evaluates ridingCondition through checkRidingCondition() to determine whether normal riding continues.

The execution of break terminates the loop immediately and transfers control to the statement following the loop. Unlike termination caused by the loop condition becoming false, this interruption does not arise from the gradual loss of control or the natural completion of repetition. Instead, it represents an explicit rule-based intervention that overrides the current flow of execution. This behavior parallels how a referee stops a wrestling match upon detecting a dangerous situation, regardless of the athletes’ ongoing actions.

From an instructional perspective, mapping referee stoppage to the break statement helps learners distinguish between two different mechanisms of loop termination. The loop condition governs whether repetition may continue under normal circumstances, while break represents an immediate interruption that exits the control structure from within the loop body. For student-athletes, the referee’s authority provides a familiar conceptual model for understanding how program execution may be halted by rule enforcement rather than by ordinary condition failure.

4.3.3. Temporary Pause and the continue Statement

While the previous example illustrates how execution can be terminated through the break statement, wrestling also provides an analogy for situations in which the ongoing action is briefly interrupted but the overall engagement continues. In a wrestling match, the referee may momentarily stop the action to adjust equipment or reposition the athletes before immediately allowing the match to resume. Such a pause affects only the current moment of action and does not terminate the engagement. This pattern corresponds closely to the semantics of the Java continue statement. The following code fragment extends the control-flow model introduced in the previous example.

boolean ridingCondition = true;
int controlTime = 0;
while (ridingCondition) {
    controlTime++;
    boolean dangerousPositionDetected = checkDangerousPosition();
    if (dangerousPositionDetected) {
        break;
    }
    boolean temporaryPause = checkTemporaryPause();
    if (temporaryPause) {
        ridingCondition = checkRidingCondition();
        continue;
    }
    ridingCondition = checkRidingCondition();
}
		  

In this program, the while loop represents continuous engagement similar to a live wrestling exchange again. The variable ridingCondition models the ongoing control state, while controlTime records the duration of the engagement. During each iteration, controlTime increases by one to represent the continued accumulation of control time. The program then checks whether a dangerous position has emerged through checkDangerousPosition(). If dangerousPositionDetected evaluates to true, the break statement is executed, and the loop terminates immediately.

The variable temporaryPause, in contrast, represents a brief referee-directed interruption that does not end the engagement. During each iteration, the program evaluates this condition through checkTemporaryPause(). When temporaryPause evaluates to true, the continue statement is executed. Instead of terminating the loop, continue skips the remaining statements in the current iteration and proceeds directly to the next cycle of execution. Before moving to the next iteration, the program re-evaluates ridingCondition through checkRidingCondition(), even when a temporary pause occurs. This ensures that the loop continues only while the riding condition remains valid.

This behavior parallels how a temporary pause operates in wrestling. The referee may halt a specific action momentarily, reposition the athletes, and then allow the match to proceed without ending the period or transferring control. The interruption affects only the current moment of engagement, while the broader structure of the match remains unchanged. If no dangerous position or temporary pause is detected, the program proceeds to re-evaluate ridingCondition through checkRidingCondition(), which allows the loop to continue only while the riding condition remains valid.

From an instructional perspective, mapping this referee-directed pause to the continue statement helps learners distinguish between different forms of loop interruption. While break terminates the control structure entirely, continue represents a localized procedural skip within an ongoing loop. For student-athletes, the familiar experience of a brief referee pause provides an intuitive model for understanding how a program may bypass part of a single iteration while maintaining the overall flow of conditional iteration.

4.4. Methods and Execution Units: Wrestling Control Positions and Java Method Semantics

To support student-athletes’ understanding of Java methods, the following mapping leverages their existing mental models of wrestling control positions. In wrestling, the interaction between the top and bottom athletes establishes a dynamic hierarchy of control that may shift through actions such as escape or reversal. A comparable structure exists in Java method execution, where method invocation creates a temporary execution context in which the caller transfers control to a method, the method body performs a defined sequence of operations, and control is subsequently returned to the caller together with any resulting value. This transfer of control parallels the positional dynamics observed in wrestling exchanges: the calling context determines when a method is invoked, the method executes within the constraints defined by its parameters and internal logic, and the return statement transfers control and data back to the calling context. To further connect wrestling positions with Java method execution,

Table 4. Mapping Wrestling Control Positions to Java Method Semantics.

Wrestling Position	Athlete’s Meaning	Java Statement	Teaching Interpretation
Top position	Dictates action	Method caller	Initiates and controls method execution
Bottom position	Limited action	Method body	Executes under caller control
Escape	Breaking control	return	Transfers control back to caller
Reversal from bottom	Changes control outcome	Returned value	Provides computed result to caller

summarizes how wrestling control positions correspond to Java method semantics.

4.4.1. Top Position and Method Caller

In wrestling, the athlete in the top position determines the timing, sequence, and nature of offensive maneuvers. Maintaining positional dominance allows the top athlete to decide when to initiate attacks while observing the opponent’s reactions. A comparable structure exists in Java method execution, where the method caller initiates the invocation of a method, determines its arguments, and processes the returned result.

public class MatchExample {
    public static void main(String[] args) {
        int score = calculateScore();
        System.out.println("Score: " + score);
    }
    public static int calculateScore() {
        int base = 0;
        base += 2;
        return base;
    }
}
			

In the above example, the main method functions as the method caller. It invokes the method calculateScore() and determines how the returned value is used in subsequent program operations. In this sense, the caller establishes the timing and context of method execution. Similar to a top-position wrestler who controls when engagement occurs, the calling method governs when a method is executed and how its outcome influences the subsequent sequence of actions. The caller therefore maintains authority over the execution flow, while the method body performs its operations only after invocation.

This analogy highlights an important structural aspect of Java methods: method execution does not occur autonomously but is triggered by an external caller. Program flow is therefore organized through explicit method invocation, which reflects a hierarchical transfer of control similar to the positional dynamics observed in wrestling matches.

4.4.2. Bottom Position and Method Body

In wrestling, the athlete in the bottom position operates under constraints imposed by the top-position opponent and the rules governing the match. The bottom athlete must select movements strategically, responding to opportunities without the ability to dictate the pace or sequence of the exchange. All actions occur within the positional control established by the opponent. A comparable structure exists in Java method execution. The body of a method does not initiate execution independently; instead, it performs operations only after being invoked by a caller that establishes the timing and execution context.

public static int calculateScore() {
    int base = 0;
    base += 1;
    return base;
}
			

In this example, the calculateScore method executes only after it is invoked by the main method, which acts as the caller. The operations inside the method body occur within the local scope of the method and do not influence the broader program flow until execution returns to the caller. In this sense, the method body resembles a bottom-position athlete whose actions occur within constraints defined by an external controller. The method performs its internal operations according to its defined logic, but the initiation and continuation of execution remain determined by the caller.

This correspondence highlights an important structural property of Java methods. Method bodies execute within a bounded context defined by invocation and scope, while control over program execution resides with the calling structure. The analogy with wrestling positions therefore illustrates how hierarchical control and constrained execution operate in method semantics.

4.4.3. Escape and return

In wrestling, an escape enables the bottom-position athlete to disengage from the opponent’s control and return to a neutral position while the match continues. A comparable mechanism exists in Java method execution through the return statement. The return statement terminates the execution of the current method and transfers control back to the calling context.

return base;
			

When this statement is executed, the method immediately stops executing its remaining instructions and passes the specified value back to the caller. Control is therefore returned to the calling method, which can then proceed with subsequent program operations. In this sense, the return statement resembles a clean escape in wrestling: the constrained execution context ends, and control shifts back to the higher-level structure that initiated the interaction.

This correspondence highlights an important structural property of method execution. The return statement provides an explicit mechanism for transferring control from a method body back to its caller, which ensures that program execution proceeds in an orderly and well-defined manner. The analogy with an escape in wrestling therefore illustrates how method execution concludes through a structured transfer of control rather than through an arbitrary interruption.

4.4.4. Reversal from Bottom and Returned Value

In wrestling, a reversal occurs when a bottom-position athlete not only escapes the opponent’s control but also gains a dominant position, thereby changing the overall match state. A comparable mechanism appears in Java through the value returned by a method. While the method itself executes under the caller’s control, the value it returns can influence the caller’s subsequent state and decisions.

int score = calculateScore(); // score updated using method result
			

In this example, the method calculateScore() performs its computation within the method body and returns a value to the caller. The returned value is then assigned to the variable score, which updates the caller’s state and affects subsequent program behavior. Although the method does not control the overall program flow during execution, the information it produces modifies the caller’s context once execution returns.

This relationship parallels a wrestling reversal. During a reversal, the bottom-position athlete operates within the ongoing engagement, but ultimately changes the outcome of the interaction by gaining positional dominance. Similarly, a method executes within the constraints defined by its caller, but the value it produces can reshape the caller’s state and influence future computation. The returned value therefore represents the outcome of a constrained interaction that subsequently alters the higher-level execution context.

This analogy highlights how method results propagate beyond the local scope of the method body and affect the broader program state. By relating returned values to the concept of reversal, the mapping illustrates how local computation can produce outcomes that modify the caller’s state and guide subsequent execution.

4.5. Error and Enforcement: Wrestling Rule Violations and Java Exception Semantics

Beyond scoring and control flow, both NCAA wrestling and Java programming rely on explicit enforcement mechanisms to preserve the integrity of execution. In wrestling, rule violations, stalling situations, and injury events trigger referee intervention, which suspends or terminates normal action in order to maintain fairness and safety. A comparable mechanism exists in Java, where exception mechanisms and runtime constraints interrupt or regulate program execution when behavior violates semantic or operational rules. Enforcement events in wrestling, such as referee whistles, penalty calls, and temporary stoppages, function as formal mechanisms regulating match progression. By mapping these enforcement scenarios to Java error conditions and exception-handling constructs, the framework establishes a conceptual correspondence between rule-based intervention in wrestling and structured error management in program execution.

Table 5. Mapping Wrestling Enforcement Actions to Java Error and Exception Constructs.

Wrestling Action	Athlete’s Meaning	Java Statement	Teaching Interpretation
Illegal hold	Rule violation	Exception thrown	Execution interrupted due to rule violation
Repeated stalling	No progress in action	Infinite loop	Execution continues without progress
Injury timeout	Temporary stoppage under referee control	Exception handling	Controlled interruption and recovery

summarizes this mapping between wrestling enforcement actions and Java error and exception constructs.

4.5.1. Illegal Hold and Exception Thrown

In NCAA wrestling, an illegal hold constitutes a direct violation of the rules. When such a violation occurs, the referee immediately stops the action regardless of the current position or momentum of the match. The ongoing engagement is invalidated, and penalties or corrective actions are enforced before the match may continue. This enforcement structure corresponds closely to Java’s exception-throwing mechanism. When an exception is thrown, normal program execution is immediately interrupted and control is transferred away from the current execution path.

if (holdIsIllegal) {
    throw new IllegalArgumentException("Illegal hold detected");
}
			

In the above execution context, throwing an exception functions as a formal rule enforcement mechanism rather than a discretionary control decision. Just as an illegal hold cannot be completed once detected, program execution cannot proceed beyond the point at which the exception is thrown. The current execution path is terminated immediately, and control is transferred out of the active context according to the language’s enforcement rules. From a wrestling perspective, this reflects the non-negotiable nature of officiating: the stoppage of action is not determined by athlete intention but by rule enforcement. Similarly, Java does not permit subsequent statements in the same execution path to execute once an exception is raised. The interruption is compulsory, rule-governed, and external to the normal program logic.

This analogy clarifies the distinction between exceptions and ordinary branching logic. Exceptions represent violations of execution validity rather than alternative paths within legitimate control flow. By relating exception throwing to referee-enforced stoppages, the mapping illustrates how program execution is halted when rule constraints are violated.

4.5.2. Repeated Stalling and Infinite Loops

In wrestling, stalling is penalized when an athlete repeatedly avoids engagement or fails to demonstrate meaningful progress. Although individual moments of passivity may not constitute an immediate rule violation, the accumulation of non-progressive actions eventually triggers referee intervention and penalties. A comparable situation can arise in Java when a loop continues indefinitely without advancing the program state or approaching termination. Such behavior is commonly referred to as an infinite loop.

boolean matchActive = true;
while (matchActive) {
    // no state update occurs
}
			

In this execution pattern, the program remains active but fails to advance its state. This situation is analogous to a wrestler who remains within bounds but does not attempt to improve position, initiate offense, or create scoring opportunities. Each iteration of the loop is syntactically valid, just as individual passive movements may be permissible within the rules of wrestling. However, because the loop does not modify the condition governing its continuation, execution becomes trapped in a cycle that does not contribute toward termination or meaningful state change.

From a wrestling perspective, referees evaluate whether a match is progressing rather than focusing solely on isolated movements. Similarly, program behavior is evaluated not only by syntactic correctness but also by whether execution advances toward a defined computational goal or termination condition. Infinite loops therefore represent a failure of progress in program execution, even though the individual instructions remain valid.

This correspondence illustrates that iteration in programming should be associated with purposeful state advancement. By relating infinite loops to stalling behavior, the analogy highlights the importance of progress and termination conditions in loop design.

4.6. Injury Timeout and Exception Handling

An injury timeout in wrestling represents a controlled interruption rather than a penalty. The referee halts the match to assess athlete safety, permits recovery when feasible, and determines whether and how the match may resume. The interruption is structured, rule-governed, and intentionally managed in order to preserve both fairness and athlete safety. A comparable mechanism exists in Java through exception handling. When an exceptional condition arises during execution, the program does not simply continue execution or terminate arbitrarily. Instead, execution is suspended and control is transferred to a predefined exception-handling context that determines how the situation should be managed.

try {
    performAction();
} catch (Exception e) {
    recoverSafely();
}
		  

In this structure, the try block represents normal program execution under standard operational rules, while the catch block represents a controlled interruption that allows the program to respond to exceptional conditions. When an exception occurs during the execution of the try block, the Java runtime transfers control to the corresponding catch block. This mechanism allows the program to evaluate the situation and execute an appropriate recovery strategy.

The parallel with an injury timeout lies in the structured management of interruption. In both wrestling and program execution, the interruption does not invalidate the entire activity. Instead, it establishes a structured mechanism that pauses normal execution, assesses the condition that triggered the interruption, and determines how execution should continue. This structured response preserves system integrity while allowing safe continuation when appropriate.

This correspondence illustrates that exception handling functions as a regulatory safeguard within program execution. Instead of representing arbitrary failure, exception handling serves as a mechanism for anticipating potential disruptions and implementing controlled recovery strategies within the program structure.

4.7. Termination: Wrestling Outcome and Java Program Completion

In wrestling, match outcomes are formally determined by specific scoring conditions. A pin (fall) immediately terminates the match and results in an uncontested victory. A technical fall ends the match when one athlete attains a predetermined point differential. These outcomes are definitive: once triggered, no further action within the match can alter the result. A comparable structure exists in Java program execution, where a program may terminate immediately due to a decisive condition or conclude naturally after reaching its logical completion point.

Table 6. Mapping Wrestling Termination Outcomes to Java Program Completion.

Wrestling Outcome	Athlete’s Meaning	Java Statement/Concept	Teaching Interpretation
Pin (Fall)	Immediate victory	Immediate program termination	Execution stops immediately
Technical Fall	Score-based victory	Normal program completion	Execution reaches its natural endpoint

summarizes the mapping between wrestling termination outcomes and Java program completion concepts.

4.7.1. Pin (Fall) and Program Termination

In wrestling, a pin occurs when the top-position athlete secures both of the opponent’s shoulders to the mat and establishes complete positional control. The referee immediately stops the match, and the pinned athlete can no longer influence the outcome. The result is definitive: once the pin is confirmed, the match concludes according to the rules of the competition.

public class PinExample {
    public static void main(String[] args) {
        System.out.println("Pin achieved.");
    }
}
			

In the above Java program, the main method defines the primary execution flow of the program. When the statements inside main finish executing, program execution terminates and control does not return to any previous point. This behavior parallels the decisive nature of a wrestling pin: once total control is established, the match ends immediately and no further action can occur. Each statement executed within the main method represents a step in the program’s execution sequence leading to completion. When execution reaches the final statement and the method finishes, the program terminates in a predictable and rule-governed manner.

This correspondence illustrates how program termination represents a definitive endpoint of execution. By relating program completion to the concept of a wrestling pin, the framework connects the idea of finality in program execution to a familiar competitive outcome.

4.7.2. Technical Fall and Program Logical Termination

In wrestling, a technical fall concludes a match not through immediate physical domination but through the accumulation of a decisive scoring advantage. Once the point differential reaches the rule-defined threshold, the referee ends the match even though the athletes remain capable of continued engagement. The termination is therefore conditional and evaluative rather than instantaneous. This structure corresponds closely to condition-based program completion in Java, as illustrated below.

public class TechnicalFallExample {
    public static void main(String[] args) {
        int scoreDifference = 15;
        if (scoreDifference >= 15) {
            System.out.println("Technical fall achieved.");
        }
    }
}
			

In this program, execution begins in the main method and proceeds normally, which is analogous to a wrestling match unfolding through active scoring exchanges. The variablescoreDifference represents an accumulated competitive state, which is similar to the point differential that develops during a match. The if statement functions as a rule evaluation mechanism comparable to a referee determining whether the technical fall threshold has been reached. When the condition scoreDifference >= 15 evaluates to true, the program executes the corresponding statement acknowledging the outcome.

Importantly, the program does not terminate simply because the condition is evaluated. Instead, execution proceeds within the established program structure and reaches its natural endpoint when the main method completes. This behavior mirrors the nature of a technical fall in wrestling. The match concludes not through abrupt interruption but through the verification of a rule-based condition derived from accumulated match states. Unlike a pin, which immediately halts the match, a technical fall represents a condition-driven conclusion based on scoring progression.

This correspondence illustrates the distinction between abrupt termination and condition-driven completion in program execution. Some program terminations occur through immediate control interruption, while others arise when accumulated program state satisfies predefined conditions that naturally conclude execution.

5. Pedagogical Implementation

This section describes how the proposed wrestling-inspired, state-based framework can be implemented in an introductory Java course designed for collegiate student-athletes. The discussion focuses on instructional sequencing, classroom practices, and the translation of conceptual mappings into concrete teaching strategies. Rather than presenting empirical learning outcome data, the purpose is to illustrate how the framework functions as a pedagogically operational approach within authentic instructional contexts.

5.1. Instructional Sequencing and Course Integration

The framework is designed to integrate naturally into the early and middle phases of a standard introductory Java curriculum. Instruction is organized through progressive alignment between programming concepts and wrestling-derived mental models, ensuring that conceptual complexity increases in parallel with students’ familiarity with both domains.

During Weeks 1–3, instruction focuses on variables, assignment, and conditional logic. These topics are introduced through state and scoring mappings derived from wrestling rules. Variables are framed as match states that exist prior to control, variable assignment as the acquisition of control through scoring actions, and conditional statements as rule evaluations that determine whether scoring conditions are satisfied. At this stage, wrestling analogies are used to stabilize novice mental models of state persistence, reassignment, and conditional execution before students encounter more complex control structures.

During Weeks 4–6, instruction shifts toward loops, methods, and program control flow. Concepts such as riding, escapes, reversals, and match termination are aligned with while loops, method invocation, return semantics, and program completion. This sequencing mirrors the increasing structural complexity of both wrestling matches and Java programs, allowing students to extend previously established mental models rather than replace them.

Within this instructional design, wrestling references function not merely as motivational elements but as structural anchors that guide how program execution is explained and reasoned about during classroom discussion.

5.2. Assessment Metrics and Tools

To evaluate whether students understand the concepts introduced through the framework, instructors may use a combination of formative and performance-based assessment tools. For program state and reassignment, students can complete code-tracing tasks that ask them to predict variable values after each statement and explain whether a new variable is created or an existing state is updated. For conditional logic, students can answer branch-prediction questions that require them to identify which block of code executes under specific input conditions. For loops, break, and continue, students can use execution-tracing tables to record loop iterations, condition values, skipped statements, and termination points. For methods and return values, students can draw call-stack or caller–callee diagrams that show control transfer and returned data. For exceptions and termination, students can identify where normal execution is interrupted and describe how control moves to a handler or to program completion.

In addition to these concept-specific tools, instructors may use short concept inventories, debugging tasks, think-aloud explanations, student-generated analogical mappings, reflective prompts, and exit tickets. Possible metrics include accuracy in code tracing, correctness of predicted output, quality of written explanations, ability to identify state changes and control transfers, successful debugging of misconception-based code, and students’ ability to explain the limits of the wrestling analogy. These assessment tools are intended for formative classroom use and can also provide a foundation for future empirical evaluation of the framework.

5.3. Classroom Enactment: Teaching Reassignment Through Reversal

To illustrate how the framework operates in practice, this section presents a representative classroom enactment used to introduce variable reassignment. The example demonstrates how wrestling-based mental models are mobilized to structure explanation, reasoning, and code interpretation.

The instructional sequence begins with a familiar wrestling scenario involving a reversal from the bottom position. Students are prompted to consider whether a wrestling match restarts when a reversal occurs. The discussion typically highlights that the match continues while control shifts from one athlete to another. This observation provides the conceptual basis for introducing variable reassignment in Java.

The instructor then presents the following code:

int score = 0;
score = score + 2;
		  

Students are encouraged to interpret this statement using wrestling terminology. Rather than focusing immediately on symbolic evaluation, the discussion emphasizes the continuity of program state. The variable score persists throughout execution, while the reassignment operation modifies the value associated with that variable.

Guiding questions focus on identifying what changes and what remains constant during execution. The value of score is updated through the reassignment expression, while the variable itself retains its identity and scope within the same execution context. This distinction highlights that reassignment represents a state transition rather than the creation of a new variable.

By drawing parallels with a wrestling reversal, the instructional sequence emphasizes that reassignment preserves continuity while shifting control over the existing state. Just as a reversal changes positional dominance without restarting the match, reassignment updates a variable’s value without resetting program execution.

5.4. Embodied Reinforcement Activity

To reinforce the concept of reassignment, the framework incorporates a brief embodied classroom activity that allows students to enact the transition of control physically. The objective is to connect students’ existing understanding of wrestling dynamics with the abstract concept of mutable program state.

In this activity, one student represents a program variable and remains stationary in the classroom to symbolize the variable’s persistent identity and scope. Two additional students represent competing athletes who alternately assume control of the variable’s state. This arrangement illustrates that reassignment updates the value associated with an existing variable without altering the variable itself.

The instructor revisits the Java example:

int score = 2;
score = score + 2;
		  

Students enact the reassignment process by transferring “control” between athletes while the student representing the variable remains fixed in position. This physical representation emphasizes that the variable continues to exist throughout the operation while the value associated with it changes through programmatic action.

During the activity, the instructor narrates the process using wrestling-aligned language. The match is described as ongoing, control is transferred between athletes, and the variable remains active throughout the exchange. This parallels the mechanics of a wrestling reversal, where control shifts within an ongoing match without resetting the competitive state.

5.5. Pedagogical Significance

The classroom enactment illustrates how the wrestling-inspired framework is intended to translate abstract programming concepts into accessible experiences for student-athletes. By mapping variable reassignment to a wrestling reversal, students observe how control over an existing state can shift while the underlying structure remains unchanged. This representation is designed to address a common novice misconception that reassignment creates a new variable or restarts program execution.

From a cognitive perspective, the activity connects prior domain knowledge of control, engagement, and rule-governed interaction with the semantics of Java execution. These connections may support the development of mental models related to state persistence, control flow, and value transformation.

Pedagogically, leveraging a familiar and meaningful domain may reduce the abstraction barrier often associated with introductory programming. Programming operations are framed as structured and rule-governed transitions rather than arbitrary symbolic manipulations. Guided questioning and immediate application to code are intended to encourage students to reason about program behavior using both domain-specific intuition and formal program semantics.

In summary, this design illustrates how domain-aligned instructional strategies can make programming abstractions more transparent and support the development of stable conceptual models. By aligning reassignment with the familiar dynamics of a wrestling reversal, the framework illustrates how instruction grounded in learners’ experience may facilitate reasoning about state change and execution continuity in introductory Java education.

6. Discussion

This section discusses the pedagogical implications, limitations, and potential future directions of the proposed wrestling-inspired programming framework.

6.1. Pedagogical Advantages

The wrestling-inspired, state-based framework offers several potential instructional advantages. First, it is designed to leverage student-athletes’ existing mental models of control, engagement, and rule-governed interaction to provide an intuitive scaffold for understanding program state and execution. Second, aligning abstract Java constructs such as variable reassignment, conditional branching, loops, and method invocation with concrete wrestling experiences are intended to reduce cognitive load and facilitate comprehension of layered programming abstractions. Finally, situating programming operations within a familiar, rule-driven context may support deeper conceptual understanding of control flow, method execution, and state transitions.

6.2. Limitations

The primary limitation of this study is that it presents a conceptual and pedagogical framework rather than an empirically tested intervention. No participants were recruited, and no classroom implementation data, pre- and post-test results, engagement surveys, interviews, student artifacts, or comparison groups were collected. As a result, the paper does not make causal claims about the effectiveness of the framework in improving Java learning outcomes. Its contribution is limited to theoretical development, conceptual mapping, and instructional design. Future research is needed to determine whether the proposed framework improves student understanding, engagement, retention, or transfer when implemented in authentic introductory Java classrooms.

6.3. Future Work

Future research should empirically evaluate the learning outcomes associated with the proposed wrestling-inspired framework. Building on the conceptual framework developed in this paper, future studies may investigate whether collegiate student-athletes who receive wrestling-inspired Java instruction demonstrate stronger conceptual understanding of program state, control flow, loop execution, method invocation, and program termination than students who receive conventional instruction. Future work should also examine how wrestling-inspired instruction influences student-athletes’ engagement, perceived relevance, confidence, and the accuracy of their mental models during programming tasks. Such studies may use structured student surveys, performance assessments, code-tracing tasks, debugging tasks, classroom observations, interviews, and analyses of student artifacts. In addition, qualitative research may explore how students use wrestling-based analogies when explaining Java concepts such as reassignment, conditional execution, loops, method invocation, and termination. Beyond empirical validation, the framework could also be extended to more advanced Java topics including object-oriented programming, inheritance, polymorphism, concurrency, and more complex exception handling. Similar instructional strategies could also be adapted to other sports, which allows educators to leverage athletes’ domain-specific knowledge to support programming education. These investigations would help evaluate the effectiveness, limitations, and generalizability of comparable analogical scaffolding across diverse student-athlete populations.

7. Conclusions

This paper introduces a wrestling-inspired, state-based pedagogical framework for teaching introductory Java to collegiate student-athletes. Grounded in mental model theory, analogical reasoning, and embodied cognition, the framework systematically maps NCAA wrestling match states and scoring actions to core programming concepts such as state creation, reassignment, control flow, looping behavior, and program termination. By leveraging student-athletes’ deeply internalized understanding of rule-governed athletic competition, the approach reframes abstract programming constructs as familiar, observable, and meaningful processes rather than purely symbolic operations.

The framework treats sport-specific knowledge as a cognitive resource that may support accurate reasoning about program execution. Motivation is not presented as an isolated enhancement but as a natural outcome of meaningful alignment between instructional design and learners’ existing knowledge structures. Detailed mappings between wrestling positions and Java execution contexts illustrate how learners can reason about persistence, control transfer, conditional evaluation, and termination without relying exclusively on syntactic explanations. Classroom enactments further illustrate how these mappings operate pedagogically through structured instructional discourse, guided questioning, and embodied activities aligned with student-athletes’ identities and experiences.

This work contributes to computing education research by proposing how domain-specific mental models can be deliberately incorporated into instructional design for a specialized learner population. Because the present study does not empirically evaluate learning outcomes, its contribution should be understood as conceptual and pedagogical rather than evidential. The framework establishes reusable instructional mappings, classroom examples, and a foundation for future empirical investigation into how sport-aligned pedagogies may influence conceptual understanding, engagement, retention, and knowledge transfer in computing education.

More broadly, this framework suggests that computing education can benefit from treating learners’ prior disciplinary expertise as a primary scaffold for conceptual understanding. Instruction that builds on deeply internalized knowledge has the potential to make abstract computational ideas more accessible, more stable, and more fully integrated into students’ cognitive repertoires.