Problem-Solving Efficiency and Cognitive Load for Adaptive Parsons Problems vs. Writing the Equivalent Code

Title of the Paper

Problem-Solving Efficiency and Cognitive Load for Adaptive Parsons Problems vs. Writing the Equivalent Code

Bibliographic Information

• Subject Area: Programming Education, Cognitive Load Theory, Adaptive Learning
• Keywords: Programming Education, Parsons Problems, Adaptive Learning, Cognitive Load, Code Writing, Teaching Efficiency, Programming Psychology

Research Background and Issues

• Issues and Challenges:

  • Beginners face high dropout rates and struggle to master foundational programming skills (e.g., syntax and semantic errors).
  • Most beginner programming practice involves writing code from scratch, which is time-consuming and prone to causing frustration, thereby reducing learning confidence.
  • Women and certain underrepresented groups are often disproportionately affected due to a lack of prior programming experience.

• Significance:

  • Enhancing diversity and inclusivity in programming and addressing failure and dropout issues in early programming courses hold significant social value.

• Research Motivation and Related Work:

  • Parsons Problems—programming tasks requiring learners to reorder scrambled code blocks—have been shown in prior studies to be more efficient than writing code from scratch, with no significant negative impact on learning outcomes.
  • There is a need for larger-scale, context-based studies (beyond laboratory settings) to validate the efficiency and cognitive load of Parsons Problems in real-world courses.

Solution

• Research Methodology:

  • Conducted an experiment comparing the efficiency and cognitive load of adaptive Parsons Problems versus equivalent code-writing tasks using a "multi-task within-subjects design."
  • Developed specific problem sets and research tools (including the cognitive load questionnaire "Paas Scale") for a Python course.
  • Introduced a "help button" as an adaptive feature to dynamically adjust the difficulty of Parsons Problems (e.g., removing distractors, merging or indenting code blocks).

• Innovations:

  • Collected contextualized data from large-scale real-world programming courses rather than traditional small-sample experiments.
  • Examined the impact of Parsons Problems on cognitive load, problem-solving efficiency, and student learning attitudes.
  • Used a "think-aloud protocol" to observe problem-solving logic, complementing quantitative conclusions from log analysis.

• Implementation Steps and Techniques:

  1. Students completed two sets of identical programming tasks: one as Parsons Problems and the other requiring code to be written from scratch.
  2. Collected data on completion time, error behaviors, and cognitive load ratings.
  3. Analyzed student preferences and learning behaviors through surveys and open-ended interviews.
  4. Incorporated a "help button" to trigger adaptive changes to reduce student confusion.

Research Findings

• Specific Results:

  • For five test problems, four Parsons Problems were significantly more efficient (shorter completion times) than writing code.
  • Adaptive Parsons Problems (especially after removing distractors) generally reduced cognitive load.
  • The "help button" proved to be a valuable aid for students in solving problems, though some detailed features (e.g., repeated merging of adjacent blocks) had the potential to mislead.
  • Found that students' learning attitudes and prior experience influenced outcomes: those with programming experience generally preferred writing code directly.

• Advantages Compared to Existing Methods:

  • Parsons Problems effectively reduced students' completion time, particularly for open-ended problems with distractors.
  • Provided new evidence that Parsons Problems can not only efficiently assess students but also teach new problem-solving strategies.

• Experimental and Evaluation Results:

  • Efficiency Analysis: Using the Mann-Whitney U test, Parsons Problems demonstrated significant time advantages in most scenarios.
  • Cognitive Load: Average ratings showed that Parsons Problems imposed lower cognitive load compared to code-writing tasks, though the differences were not significant in some cases.
  • Behavioral Observations: Some students tended to overuse the "help button" to achieve higher scores rather than understanding the problem logic.

• Limitations and Future Directions:

  1. Limitations:
     • This study was based on a specific Python course and may not generalize to other programming languages or course contexts.
     • The cognitive load scale (Paas Scale) used is a subjective measure, requiring further validation through objective methods such as eye-tracking.
  2. Future Directions:
     • Optimize Parsons Problem generation methods based on common student code patterns (e.g., clustering using abstract syntax trees, ASTs).
     • Design more effective distractors and feedback mechanisms for the help feature.
     • Explore seamless integration of Parsons Problems and code-writing tasks (e.g., dynamic mode switching for different learners).

Implementation and Educational Impact

• Develop flexible online tools (e.g., Parsons-support platforms like "Runestone") to accommodate diverse learners.
• Enhance teachers' ability to use interactive tasks for assessing learning in large-scale classrooms.
• Further validate the role of Parsons Problems in facilitating beginner programming, especially in helping students overcome initial learning hurdles.