The C programming language is one of the most widely used programming languages, with applications ranging from embedded systems, operating systems, to performance-critical applications (Hart et al., 2023). As a prerequisite for core courses in computer science, information technology, and engineering, such as Data Structures, Single-Chip Microcontroller Systems, and Principles of Microcomputers and Interface Techniques, it serves as a fundamental course for numerous majors in Chinese universities (Liu et al., 2013). The primary objectives of C programming courses include developing students’ programming skills, cultivating computational thinking, and improving the ability to solve complex real-world problems through programming (Yu et al., 2023; Keppens and Hay, 2008; Wang et al., 2017). These competencies are critical for succeeding in follow-up courses. Students who fail to master C programming fundamentals will struggle in subsequent subjects. For instance, students unfamiliar with pointers and structures may require significantly more time to comprehend data structures such as linked lists. Similarly, those lacking proficiency in C syntax will face challenges in Single-Chip Microcontroller Systems, as C serves as the primary programming language in this domain. This demands strong self-motivation and self-discipline. Otherwise, students may experience self-doubt and lose interest in learning. Worse still, subsequent programming-related courses could become insurmountable obstacles, potentially hindering academic progress, career opportunities, and pursuit of advanced degrees.

In fact, C programming is considered one of the most challenging courses for undergraduates (Dilshodov and Adxamjonov, 2023; Xu et al., 2020). The challenges stem from multiple factors. Unlike natural languages, its complex syntax rules and low-level abstractions create inherent barriers (Cheah, 2020). Novice learners often remain confused without sustained practice. Furthermore, since most freshmen lack prior programming experience, and many are accustomed to passive learning, they rarely engage in self-directed C programming practice, preferring step-by-step instructor guidance (Liu et al., 2013). Consequently, they struggle with fundamental constructs like loops and arrays, which hampers writing functional functions and procedures. This erodes learning motivation, ultimately affecting career prospects. Additionally, the sheer volume of course content coupled with dry instructional methods exacerbates the issue. Lectures dominated by slide-reading diminish learning engagement, fostering perceptions of C programming as uninteresting. Consequently, students neglect essential practice despite its critical role in mastering programming. This creates a vicious cycle: inadequate practice perpetuates skill gaps, further discouraging learning efforts.

Many methods have been proposed to improve teaching quality. Common approaches for teaching programming include lecture-based instruction, lab sessions, software visualization tools, and problem-based learning frameworks (Santos et al., 2020). For example, researchers have introduced adaptive learning activities that incorporate the Revised Bloom Taxonomy (RBT) to align with students’ cognitive skills in programming education (Troussas et al., 2020). Empirical evidence suggests that adaptive teaching methods consistently outperform non-adaptive approaches (Troussas et al., 2020). Leveraging the computational power of mobile devices, educators are increasingly adopting educational games. Gamification—the integration of game-design elements (e.g., points, badges) into instructional contexts—has proven effective in enhancing student engagement and interest (Elshiekh and Butgerit, 2017). This strategy has been successfully implemented in C programming courses (Ibanez et al., 2014), with studies demonstrating its positive impact on learning outcomes (Ibanez et al., 2014). Further research evaluated the gamified Android application C-rocks as a pedagogical tool for C programming (Talingdan and Llanda, 2019), concluding that the app significantly improved student performance (Talingdan and Llanda, 2019). Similarly, the App Inventor platform has been utilized to motivate engineering students through game-based C syntax learning (Dolgopolovas et al., 2018). Additionally, precision teaching frameworks grounded in behavioral psychology principles have been developed for programming education (Yu et al., 2023). These frameworks operationalize three structured teaching phases and five core instructional skills, resulting in enhanced teacher-student interactions and higher learning efficiency compared to traditional classrooms (Yu et al., 2023). Despite these innovations, a substantial proportion of students continue to struggle with acquiring programming competencies and failing course assessments. Emerging approaches such as heuristic teaching—recently validated in domains like Chinese composition (Xue, 2022)—may offer promising solutions for programming education. The heuristic teaching method has been demonstrated as a highly effective approach for improving pupils’ teamwork skills through structured organization of physical education lessons (D’Isanto et al., 2022). Heuristic learning, a learner-centered pedagogy, enables students to actively construct knowledge, redefine curricular objectives, and autonomously develop learning frameworks via self-directed processes that integrate continuous diagnosis, metacognitive reflection, and systematic knowledge organization (Pisarenko and Zatona, 2024). This method offers distinct advantages, including fostering student initiative, stimulating intrinsic motivation, and facilitating self-actualization within the learning process (Pisarenko and Zatona, 2024). Broadly defined, heuristics represent experience-based problem-solving strategies that guide cognitive exploration (Wakhata et al., 2023). The concept of heuristics traces its origins to an ancient Greek philosophical paradox: “How can we search for what we do not know, and if we know what we are looking for, then why should we look for it?” (summarized as the science of discovery) (Nokhatbayeva, 2020). Its pedagogical roots lie in Socratic dialogs, where knowledge emerged through resolving contradictions in discourse (Nokhatbayeva, 2020). In modern education, the Socratic method informs the design of heuristic activities, exemplified by mathematician George Pólya’s systematic heuristic framework for problem-solving through sequenced questioning aimed at cultivating critical thinking (Nokhatbayeva, 2020). As articulated by Russian psychologist Kapterev, “Heuristic form of teaching is one in which scientific laws, formulas, rules and truths are discovered and developed by the students themselves under the guidance of the teacher” (Nokhatbayeva, 2020). While this approach has profoundly influenced mathematics education (Nokhatbayeva, 2020), its application to C programming courses remains unexplored to date. Given heuristic teaching’s capacity to enhance learning motivation, promote active engagement through self-discovery, and improve academic outcomes, this study designs a heuristic-based instructional framework. We exemplify this methodology through a case study on loop structure instruction, detailing its pedagogical design and practical implementation.

The remaining of the paper is organized as follows. In Section 2, we will explain the design and application of heuristic teaching in the programming courses. The teaching of loop structure is taken as an example. The results and discussions are shown in Section 3. And the conclusions are shown in Section 4.

In designing and implementing heuristic teaching methods, we integrate principles from the Contextual Teaching and Learning (CTL) model and Problem-Based Learning (PBL) framework. The philosophical foundation of CTL lies in constructivism, which emphasizes knowledge construction through contextual connections—bridging abstract concepts with lived experiences or real-world applications—rather than rote memorization (Kia, 2023). PBL, grounded in cognitive psychology, adopts a “problem-driven learning” paradigm that inverts traditional instruction by prioritizing problem exploration before knowledge transmission. By synthesizing heuristic methods with CTL and PBL, we formulated the following pedagogical tenets for C programming:

Problem Contextualization: Embed syntax learning within authentic programming scenarios to stimulate cognitive engagement (shifting focus from “how” to “why”).

As the loop structure constitutes one of the three fundamental constructs in structured programming and serves as the conceptual foundation for subsequent chapters (e.g., arrays and linked lists), we select it as a paradigmatic case to demonstrate the design and implementation of heuristic pedagogy in C programming. Prior to this instructional unit, students have achieved mastery of sequential and selection structures. The proposed lesson plan spans 120 min. At the beginning of the loop structure, we show a clip from the movie Edge of Tomorrow to show the cycle of death and resurrection. Then, we show students a clock with second hands keeping running (lasts about 5 min). Thus, students would have an intuitive sense of the loop. Next, we tell students about the story of Gauss and ask them to list the solutions they can think of for the calculation of the sum of 1 to 100. After students share three or four solutions, we ask them to think about how we can solve this problem by C programming. Assuming that we do not know the sum formulas of arrays, students will try to write a sequential structure program as they have learned the sequential structure. One possible sequential program example is shown in Table 1.

Note that the programming tasks can be completed in class since students can implement them on their mobile phones with C compilers installed. After they finish the tasks, we ask students to analyze the disadvantages of the program in Table 1. One disadvantage is its excessive length due to repetitive expressions. Another drawback is that calculating the sum from 1 to 1 , 000 would require writing numerous similar statements (this phase lasts about 10 min). We then ask students to identify the commonality among these statements. These can be generalized as sum = sum + i , where i takes values 1 , 2 , 3 , … , 100 . Thus, the result can be computed by iteratively executing these generalized statements with incrementing i values. This process forms a loop, as it repeatedly executes two operations: sum = sum + i and i = i + 1 — analogous to the cycle of death and rebirth or the movement of a clock’s second hand. Through this analogy, the loop structure is introduced, enabling students to better grasp its execution mechanism. Finally, we provide students with the optimized program solving this problem, as shown in Table 2.

Substantially, based on the program shown in Table 2, we describe the execution process of the for-loop structure in detail using debugging within the integrated development environment (IDE) Dev C++, which directly displays the changes in variables such as i. This approach helps students better understand the for-loop structure. After that, we guide students to summarize the syntax and characteristics of the for-loop structure. Based on this summary, we visually demonstrate the execution process using an animated flowchart in PowerPoint, showing the workflow with a red point traversing the diagram. Next, we ask students to modify the program to calculate the sum of numbers from 1 to 1,000 using the C compiler installed on their mobile phones. We then propose extension challenges sequentially: calculating the sum of odd numbers and even numbers within [ 1 , 1 , 000 ] . Once these problems are solved, students gain familiarity with the basic usage of the for-loop structure. Furthermore, we allocate 5 min for them to practice calculating the sum of numbers divisible by five within [ 1 , 1 , 000 ] . This exercise not only reinforces their mastery of the for-loop structure but also revisits the selection structure through checking divisibility by five. The entire process lasts about 25 min.

After finishing the practice, we teach students the knowledge of the while-loop structure and do-while loop structure through multimedia technology such as animated flowcharts with a red point indicating execution progress. To better master the while-loop and do-while loop, students are asked to implement the functionality of the above programs using different loop structures. Furthermore, students are asked to compare the differences between these three loop structures (lasting about 20 min). Then, we ask students to write a program that outputs a 10-star pattern using a loop structure, as the visual patterns are intuitive (Figure 1). They can use any of the three loop structures. We demonstrate the while-loop structure as an example (Table 3).

After demonstrating the execution process with Dev C++, we ask students to design a program that outputs an 8-row by 10-column star pattern (Figure 2). We invite three students to demonstrate how they would write this program. After their presentations, we provide a solution where one loop controls the rows and a nested loop within it controls the number of stars per row, similar to the previous program. Through this, we introduce the concept of nested loops—embedding additional loops inside a primary loop statement—to achieve multi-level data traversal and processing. We then explain the core principles of nested loops. Subsequently, we provide students with an example program (Table 4) intended to print Figure 2, but containing intentional errors. When students execute the given program, they observe that only a single line of 10 stars (Figure 3) is printed instead of the expected pattern. We ask them to diagnose why the output differs from the target by debugging the program and monitoring changes in loop control variable values.

Subsequently, a student is randomly selected to explain their reasoning. We then analyze the program and clarify the reason: a loop terminates when its continuation condition becomes false. Specifically, after the inner loop completes execution, the value of its control variable no longer meets the loop’s continuation condition. When the outer loop iterates again, the inner loop’s control variable must be reinitialized. Students are therefore instructed to modify the program in Table 4. Next, we ask them to implement the same functionality using a for-loop structure and determine whether this issue persists with for loops. This ensures students fully comprehend nested loop execution and develop awareness of loop control variable management. Following this, based on Figure 2, students are tasked with writing a program to output Figure 4. They then progress incrementally to develop programs for Figures 5–7. Note that Figure 5 differs from Figure 4 in that the number of lines is dynamically determined by user input.

After completing the previously mentioned patterns, we increase the complexity of programming practice by integrating character manipulation with standard I/O operations. Students are tasked with generating patterns composed of characters (Figure 8). Next, they are required to produce patterns based on a user-input uppercase letter—for example, inputting “G” generates the pattern in Figure 9. To account for potential errors, the program prompts users to re-enter if the input is non-uppercase, continuing this validation loop until valid data is received (Figure 10). Through this exercise, students progressively learn to design interactive menus using loop structures and selection statements (taught prior to loops). The entire activity is designed to be completed within approximately 60 min.

Throughout these heuristic teaching activities, students actively engage in thinking, learning, and practicing during class. With frequent questioning and interactive practices progressing incrementally from simple to complex tasks, students remain motivated and cognitively engaged. Finally, we assign homework requiring them to generate a specific pattern based on a user-input uppercase character (Figure 11).

We began teaching C programming courses to Medical Information Engineering majors at Anhui Medical University in the fall 2021 semester. Based on preliminary surveys conducted during the first class, these freshmen (predominantly from Anhui Province) had minimal programming exposure, with C programming being their first formal coding course. Most lacked foundational computer science knowledge. By the semester’s end, we observed persistent difficulties in their ability to acquire programming skills and develop computational problem-solving competencies. Consequently, we implemented pedagogical reforms for the 2022 fall semester cohort of the same program (comprising students mainly from Anhui Province, with one exception from Shanxi Province). Adopting heuristic teaching methodologies with customized case studies, we maintained instructional continuity as outlined in Section II. Notably, due to logistical constraints—including shared theoretical coursework with master’s degree students—we could not conduct parallel controlled experiments within the same semester (i.e., traditional vs. reformed methods). Furthermore, implementing differential teaching approaches risked student objections, as course grades directly impacted scholarship eligibility. Therefore, uniform instructional strategies were applied within each cohort. However, the students of the 2021 and 2022 fall semesters can be seen as two contrast groups to a certain extent because they are taught by the same teacher with the same teaching hours. Only the teaching methods are different. In fact, these students are with the same curriculum. The C programming lessons are both 45 teaching hours. Thus, the examination scores and student evaluation scores of teaching performance are used as indicators to show the efficiency of the proposed teaching methods. Note that each topic in the 2022 fall semesters was taught by the same teacher consistent with that in the 2021 fall semesters. Moreover, the examination papers have the same level of difficulty with the same emphasis. The examination scores are shown in Table 5.

As shown in Table 5, the average examination scores for C programming courses in 2021 and 2022 were 72.9 and 77.2, respectively. While differences in scores could theoretically arise from factors like student backgrounds, instructor variations, or teaching methodologies, several observations suggest these variables were controlled: All students except one originated from Anhui Province; both cohorts consisted of Medical Information Engineering freshmen with comparable age profiles (average ages 17.91 in 2021 vs. 17.90 in 2022) and minimal programming experience. The 2021 cohort included 59 students (30 male, 29 female), while the 2022 cohort had 88 students (52 male, 36 female). Crucially, the same instructor delivered all course content. Given these stabilized conditions, the 4.3-point score increase in 2022 implies the heuristic teaching reforms contributed to improved outcomes. Statistical validation was conducted through a one-tailed t-test (justified by similar standard deviations: 9.1 for 2021 vs. 9.9 for 2022), yielding a p-value of 0.00447—significantly below the 0.05 threshold. The 95% confidence interval [ − ∞ , − 1.61 ] indicates the 2021 cohort’s mean score was at least 1.61 points lower than 2022’s. A Cohen’s d value of 1.38 confirms a large effect size. Supporting evidence emerges from score distributions: the 2021 modal range was 70–79 (Figures 12, 13), shifting to 80–89 in 2022. Notably, both the highest and lowest scores in 2022 marginally surpassed 2021’s extremes. These findings collectively demonstrate the pedagogical effectiveness of the redesigned heuristic teaching framework.

We also find that although students of the same semester attend the same classrooms together, however, the scores differ with classes (Figure 14). For freshmen of the 2021 fall semester, they were divided into two small classes. The average scores of these two classes are 71.93 and 73.86, respectively. For freshmen of the 2022 fall semester, they were divided into three classes. The average scores of these three classes are 79.17, 77.79, and 74.31. As students of the same semester attended theory classes of C programming together, they were instructed with the same teaching contents and methods. However, the scores are still different. We guess that this may be caused by class discipline and academic atmosphere as they doing C programming practice in the units of classes. According to our experience in experimental programming classes, for classes with higher scores, more students would ask questions or discuss problems during programming. In contrast, some students were addicted to mobile video games. Some of them even tried to play mobile video games when others were programming. Of course, they would be stopped from playing games in classes. Thus, we think the differences in examination scores between classes of the same semester may be caused by class discipline and academic atmosphere. This will be our future research direction to further improve the teaching efficiency while analyzing factors affecting teaching efficiency and minimizing the difference between classes. Also, we need to develop more suitable evaluation approaches such as formative assessment and project assessment into our teaching process in the future research. This is one of the limitations of the work.

After the C programming course concluded, students were asked to evaluate teaching performance through scoring. Following the implementation of the proposed method, teaching evaluation scores increased from 90.73 to 94.53. Many students noted that complex concepts became easier to understand as the designed cases and targeted analyses by teachers effectively connected abstract theories with practical understanding. Some students highlighted that the praxis-oriented approach, integrating theoretical frameworks with contextualized applications, strengthened their learning processes. Student feedback further confirms the efficacy of these teaching methods. The proposed method may be applied to other computer science courses. For example, object-oriented programming classes such as Python and Java also involve loop structures. The teaching process can be adapted to suit these courses. The framework can further extend to data structure instruction. For instance, animations may directly demonstrate linked list operations or binary tree traversal, while physical analogies (e.g., stacking plates) could explain stack push/pop mechanisms. This approach thus helps students better understand abstract concepts.

The C programming language has various applications and is also a prerequisite for courses such as Data Structures, Object-oriented Programming, and Embedded Systems. However, C programming remains one of the most difficult courses in many majors, with a high failure rate. Failure to learn C programming may not only decrease students’ motivation in learning programming languages but also increase the difficulty of mastering knowledge related to subsequent courses. Furthermore, this may affect their future career prospects.

To improve the teaching efficiency of C programming classes offered to freshmen majoring in Medical Information Engineering at Anhui Medical University, we designed teaching cases based on heuristic teaching methods and implemented them starting in the 2022 fall semester. Since the loop structure is foundational for subsequent topics such as arrays and pointers, we used it as an example to demonstrate case design strategies and stimulate students’ learning interest. We utilized examination scores as an indicator to evaluate the effectiveness of the designed cases and heuristic teaching methods. As the students were freshmen with no prior programming experience, this metric is valid. Results indicate that with the heuristic-based cases, the average score rose from 72.9 (2021) to 77.2 (2022), while teaching evaluation scores increased from 90.73 to 94.53. This demonstrates that the heuristic teaching cases significantly enhance instructional efficiency in C programming courses. We believe these methods could inform pedagogy in other computer-related subjects.