From Blocks to Text: Bridging Programming Misconceptions

Abstract

The use of a pedagogical approach mediated transfer with the bridging method has been successful in facilitating the transitions from block-based to text-based programming languages. Nevertheless, there is a lack of research addressing the impact of this transfer on programming misconceptions during the transition. The way programming concepts are taught to K-12 learners can later result in misconceptions for adult learners. The main objective was to examine the impact of mediated transfer using the bridging method pedagogical approach on the prevalence of programming misconceptions. We conducted a quasi-experimental study in school settings during informatics (computer science) classes among 163 sixth-grade students. The control group received traditional programming lectures using the text-based programming language, Python. Conversely, the experimental group utilized a mediated transfer pedagogical approach by starting with the block-based programming language MakeCode for micro:bit before transitioning to the text-based Python. Our findings indicate that the experimental group significantly reduced programming misconceptions in fundamental programming concepts: variables, sequencing, selection, and loops - compared to the control group. This suggests that the use of block-based programming language as an initial step in programming education, followed by a structured transition to text-based programming language, can effectively mitigate common misconceptions among K-12 learners.

Keywords

programming misconceptions programming novices Python MakeCode for micro:bit K-12

Introduction

Since programming and computational thinking are now recognised as essential skills for K-12 students, they have been incorporated into many national curricula worldwide. However, traditional programming lectures often rely on text-based programming languages (TBPL) like Python, which require a level of abstract thinking that K-12 students may not have fully developed. Consequently, educators often resort to block-based programming languages (BPL), like Scratch, for K-12 programming lectures. The main advantage of BPLs is the elimination of syntax errors because the instructions come in the form of interlocking blocks, which simplifies coding and emphasizes problem-solving skills.

However, transitioning from BPLs to TBPLs poses several challenges. BPLs should serve as a stepping stone towards TBPL, which is our final objective in programming classes. Although such a transfer seems logical, there are three main issues in that process: (a) the differing programming paradigms between the two environments, (b) the transfer of learned programming concepts from one environment to the other, and (c) the programming contexts.

The dominant programming paradigm in BPLs like Scratch, is usually functional or object-oriented (Krishnamurthi & Fisler, 2019). In contrast, teaching programming using TBPLs, such as Python, mostly adheres to the procedural paradigm. Fundamental algorithms taught to beginners include sequencing, selection, and iteration. Given that Scratch is inspired by Logo, it also inherits its programming paradigm. These environments feature microworlds with programmable objects, such as the “turtle” in the Logo. BPLs allow us to impact the behaviour and appearance of such objects. The context for programming BPLs typically involves games, animations, and similar scenarios which allows for an easy introduction of basic programming algorithms in a short time.

In contrast, teaching programming using TBPL is mostly based on the procedural paradigm, and the context often revolves around solving math problems. For instance, from BASIC in the 1980s to Python today, variables are introduced as a fundamental concept in the procedural paradigm because they are essential to the functionality of all procedural programs. Conversely, in languages like Logo or some BPLs, it is even possible to implement recursion without using variables.

Consequently, the transition from BPL to TBPL is characterized by differences in programming paradigms, contexts, and core programming concepts. The pedagogical approach of mediated transfer may assist in bridging that transition between programming environments. There are several studies, ranging from the K-12 to the undergraduate levels, that support the use of mediated transfer for the transfer of learned programming concepts between these two environments (Chetty & Barlow-Jones, 2012; Dann et al., 2012; Krpan et al., 2017; Mladenović et al., 2021; Tabet et al., 2016; Žanko et al., 2023). Nevertheless, there is a lack of research addressing the programming misconceptions that may arise in such an approach (Žanko et al., 2023). How does the transition between programming environments affect programming misconceptions? In this paper, we aim to offer some answers to posed questions based on our study conducted at the K-12 level.

Considering all mentioned above, we aim to address the following research questions:

RQ1: Does the use of Block-based Programming Language (BPL) for mediated transfer to Text-based Programming Language (TBPL) impact students’ programming misconceptions for fundamental programming concepts?

RQ2: What are the most frequent programming misconceptions in TBPL and BPL among K-12 students?

The following section will present a literature review related to misconceptions, followed by the methodology of our study, and concluding with the results and the discussion.

Background and Literature Review

Programming misconceptions have been identified as an important issue since the beginning of the computer science research in the 1980s. A comparison of the identified misconceptions and their causes since the 1980s (Bonar & Soloway, 1983, 1985; Du Boulay, 1986; Kurland & Pea, 1985; Mayer, 1981; Pea, 1986; Soloway et al., 1982; Spohrer & Soloway, 1986) to those found in the last decade (Alexandron et al., 2012; Brown & Altadmri, 2014; Kohn, 2017; Sirkiä, 2012; Sirkiä & Sorva, 2012; Sorva, 2018) reveals that, despite noticeable differences inn programming languages, contexts, and the ages of programming novices, the challenges faced by beginners in programming remain remarkably similar. All aforementioned studies are related to the university level of education because Computer Science (or Informatics – a term commonly used in Europe) is still underrepresented in K-12 curricula as a separate school subject, resulting in a shortage of studies related to that educational level. Furthermore, despite the widespread adoption of BPLs into K-12 programming education, there are still not enough studies about students’ misconceptions within such environments.

For the literature review related to the programming misconceptions at the K-12 level, we queried databases WoS, SCOPUS, and ACM by title, abstract, and/or keywords with the query terms: misconceptions AND programming AND ( “computer science” OR CS OR informatics) AND ( k-12 OR K12 OR “K 12” OR “elementary school”). The exclusion criteria included duplicates, papers not related to students’ misconceptions (some were related to teachers’ misconceptions), and papers with no experimental study. Initially we detected 38 papers, but after applying the exclusion criteria, only nine papers were related to the studies conducted at the K-12 level (elementary, middle, or high schools) level. In the following section, misconceptions identified in BPLs and TBPLs within the K-12 level are presented.

Misconceptions at the K-12 Level

Among papers dealing with the programming misconceptions at the K-12 level when TBPLs were utilized, four papers were extracted. One study was conducted among 33 middle-school students in China over a 14-week Computer Science course that used the Pascal programming language. The authors identified misconceptions through the analysis of incorrect solutions. Among the ten detected errors, six were common syntax errors (missing semicolon, missing begin statements, full stop errors, Chinese character input errors, identifier not found, mismatched parenthesis, absent then statements), while four pertained to variables and their operations (illegal expression, incompatible types, issues with colons) (Qian & Lehman, 2018).

Two related studies involved elementary school students in programming lectures using Python. The first study (Žanko et al., 2019) detected four misconceptions concerning variables: (a) Assigning an expression instead its evaluated value; (b) Holding multiple values at a time; (c) When updating a variable’s value, assigning the sum value to the variable; (d) Using the symbolic name of the variable instead of its value. The second study (Žanko et al., 2022) detected three additional variable related misconceptions: (e) Data type misconceptions; (f) Sequencing misconception; and (g) Swapping variable values.

BPLs are likely more appropriate for introductory programming lessons at the K-12 level, but their role is to prepare the students for a seamless transition to TBPLs – a concept referred to as the “low floor” (Guzdial, 2004; Resnick et al., 2009), which aims to ease the transfer of programming concepts from one environment to another. Nonetheless, students can also develop specific misconceptions in BPLs.

It is reported that in comparisons between K-12 students’ success in TBPL Python and BPL Scratch, students using Scratch had significantly fewer misconceptions regarding nested loops, although the frequency of such misconception was 50% for Scratch students (Mladenović et al., 2018). Misconceptions related to nested loops when using BPL are also confirmed, with K-12 students often executing only the outer loop. However, difficulties with simple loops were also reported nearly frequently as nested loop misconceptions (Bentz & Standl, 2023). Another study dealing with the loop misconceptions using BPL Bockly identified four distinct misconceptions. Two of them (a) no command is inserted into a repeat block, and (b) the number of repetitions in a loop cannot be changed, were less common (9.6% and 13% respectively) and are easier to overcome. Another two, (c) one block in a loop (30%), and (d) a series of repeat blocks (25%) were more significantly represented and not as easy to overcome (Vaníček et al., 2022).

When BPL is used in introductory programming among middle-school students, students are generally unfamiliar with the variables, expressions, and operators, showing that BPL assists with syntactic comprehension but conceptual difficulties remain (Grover & Basu, 2017). Another study conducted among students from 7- to 17-year-olds in BPL Scratch identified the three most common misconceptions as: (a) the difficulty of understanding the sequential execution of statements, (b) the difficulty of comprehending that a variable stores one value at a time, and (c) the difficulty to understand the interactive nature of a program when a user input is required (Swidan et al., 2018). The foundations of detected misconceptions could be found in several previously detected causes of misconceptions, such as: the lack of or faulty mental models (Ben-Ari, 2001), students’ faulty mental models based on math preconceptions (White, 2001), the influence of the semantic meaning of the variable name coupled with incorrect expectations of program outputs (Pea, 1986).

Issues in Transition from Blocks to Text

Combining block-based and text-based elements within a single system can have certain benefits (Kölling, 2023). As previously noted, BPLs could facilitate the transfer of acquired concepts towards TBPLs. However, there are only a few studies exploring the impact of such combined approach on misconceptions. The problem of transfer between two environments extends beyond the syntax itself. The problem may occur when two environments endorse different programming paradigms and contexts, further complicating the transition. For example, transition from Scratch to Python in introductory programming courses is very demanding because of several reasons:

a) The two languages support different programming contexts: Scratch is primarily designed for programming games, animations, storytelling, etc.., whereas Python, when used in a traditional introductory programming lectures, is typically employed for solving math-based problems. Thus, these different programming contexts contribute to the development of different mental models.

b) Scratch primarily inherits Logo programming paradigm, which is functional, but it also fits into object-oriented approach. In contrast, Python, during introductory programming lessons adheres to imperative and procedural paradigms. Again, these different programming paradigms affect the development of students’ mental models.

The difficulty of transitioning can be demonstrated using one of the basic programming concepts – the variable. In Scratch, similar to Logo, it is possible to program animations and even implement recursion without using variables. That is why students often lack familiarity with variables, expressions, and operators after attending BPL programming lectures (Grover & Basu, 2017). On the other hand, within a procedural paradigm, variables are essential and without them, the scope of potential solutions is quite limited. Therefore, when designing programming lectures that involve transitioning between environments programming context and paradigms should be carefully considered. For example, the transition from Logo to Python using the turtle library [31] is “natural” because they share similar programming paradigms and contexts.

However, reports indicate that students who learned programming using TBPL Logo rated their programming competence higher compared to students who started with BPL Scratch before transitioning to TBPL Logo. Additionally, no differences were found in the understanding of loop concepts between these two groups (Lewis, 2010). Similar results are noted in recent study in which one group of secondary group students used TBPL exclusively, while the other transitioned from BPL to TBPL over a 13-week programming course. The results showed that students who used TBPL from the start (1) significantly outperformed in computational thinking skills; (2) had more code-writing and debugging behaviours and fewer irrelevant behaviours, and (3) more frequently interacted with the instructor. Moreover, there were no significant differences in levels of enjoyment, confidence, and interest in programming between the two groups (Sun et al., 2023).

The authors had previously conducted a study focused on the transfer of programming concepts from BPL MakeCode for micro:bit to TBPL Python, using a mediated transfer pedagogical approach. BPL MakeCode for micro:bit was selected due to its ease of structuring lectures in line with the procedural paradigm and creating a programming context that correlates directly with TBPL Python. The results indicated that BPL not only facilitated the successful mediated transfer of fundamental programming concepts such as variables, selection and loops to TBPL Python (Mladenović et al., 2021), but also that students’ misconceptions in Python were significantly reduced after the use of BPL (Žanko et al., 2023). The study presented in this paper is based upon the findings of that research (Žanko et al., 2023), broadening both the context of the research and the number of involved participants.

Methodology

This study is a continuation of a previous research aimed at identifying programming misconceptions across various programming environments at the K-12 level (Mladenović et al., 2018, 2019; Žanko et al., 2019, 2022, 2023). In this research, we conducted a quasi-experimental design study to compare misconceptions about basic programming concepts among sixth-grade students. The study was conducted during regular informatics classes at an elementary school, thereby maintaining the participants’ natural learning environment, which contributes to the external validity of the study.

Research Context

According to the national curriculum in Croatia, programming is one of four fundamental domains within the informatics school subject. While the choice of programming language is not strictly specified, Python is commonly used as the primary programming language. Informatics is a mandatory school subject in fifth and sixth grades, ensuring that all sixth-grade students have some programming experience with Python. In the fifth grade, students are introduced to programming concepts such as variables, sequencing algorithm, and loop algorithm using Python. In the sixth grade, the curriculum builds on fifth-grade topics and introduces new programming concepts such as selection algorithm and conditional loops. The national curriculum employs a spiral approach, revisiting each topic in more depth in subsequent grades, which allows a gradual progression and the introduction of new concepts that build upon previously acquired knowledge.

The experimental study was conducted among sixth grades in elementary schools during 2019/2020 school year. Prior to the experiment, all students completed a pre-test in Python that assessed the programming concepts learned in the fifth grade. The pre-test was used to verify the equivalence of the groups.

In the control (C) group, students underwent 16 school hours of conventional programming lectures using Python as the text-based programming language. Immediately after programming lectures, students completed a Python post-test.

In the experimental (E) group, students initially received 8 school hours of programming lectures using BPL MakeCode for micro:bit. MakeCode was selected because it allowed for the design of lectures that facilitated mediated transfer, supporting the procedural paradigm and a programming context appropriate for future transfer to another language. A more detailed explanation of the programming context and task examples can be found in paper (Mladenović et al., 2021).

After the lectures, students were given the MakeCode post-test. Afterwards, they proceeded with 8 school hours of programming lectures using Python, concluding with another post-test, this time in Python.

The Python post-tests for both E and C groups were identical, ensuring comparability of the results. Likewise, the MakeCode post-test was designed to parallel the Python post-test, thus enabling a comparison between the two programming approaches.

This approach allowed for a comprehensive assessment of student performance and facilitated a comparison of the outcomes obtained from the different tests and programming languages employed.

Participants

The study included a total of 163 such students in 8 classes from three elementary schools. Of these, 73 students were assigned to the E group, while 90 students were assigned to the C group. The lectures were conducted by two informatics teachers within their regular classes, thus ensuring the natural environment of the research. Each teacher had at least 10 years of experience in teaching informatics. Their expertise not only ensured a consistent and high-quality delivery of the programming curriculum but also contributed to the external validity of the research.

Given that the lectures spanned 8 weeks (16 school hours), with an additional week dedicated for conducting the tests, we took into account only the results from students who participated throughout the entire process. It is noteworthy that students were not subjected to grading or assigned homework during the research, contributing to the external validity of the study. Moreover, participant anonymity was rigorously maintained, as data analysis and reporting were conducted without any reference to personal identifiers, ensuring that it is not possible to identify any participant by the data presented in the paper.

Assessment Instruments

All three tests used in this research had been utilized in several previous studies (Mladenović et al., 2020; Žanko et al., 2022, 2023) in identical or similar forms. In each of these studies, the test metrics consistently indicated very good to excellent reliability, mirroring the findings obtained within this study.

The Python pre-test (PT) was specifically designed to assess the level of understanding of programming concepts taught in Python and to ensure the equivalence of groups in terms of their prior knowledge. The test consisted of 8 multiple-choice tasks related to the learning outcomes covered in the fifth grade. Appendix A shows PT tasks.

The PT demonstrated a high level of internal consistency, reflected by a Cronbach’s alpha coefficient of 0.814 (n = 8). Kolmogorov-Smirnov test was used to analyse the data distribution. The results (p = .000) indicated that data did not follow a normal distribution.

Post-tests: as mentioned before, the MakeCode post-test (MPT) and Python post-test (PPT) were designed to be comparable. The tests were divided into the following sections: variables and sequencing algorithms (8 items), selection algorithms (6 items) and loop algorithms (6 items). All items (n = 20) were multiple-choice question (MCQ) type, with one correct answer out of five options. Tests were designed to measure the participants’ understanding of learned programming concepts and, more specifically, to identify known misconceptions related to these concepts. It is important to note that the incorrect MCQ answer choices were intentionally constructed to correspond with potential misconceptions.

Additionally, the test contained 9 open-ended questions (OEQ) divided into two parts: the first was related to variables and sequencing (4 items), while the second part focused on the loop algorithm (5 items). In this paper we analysed MCQ task. Table 1 shows the metric characteristics of the tests.

Table 1.

The Metric Characteristics of the Post-Tests.

		Mean (%)	Median	Mod	Min	Max	Number of items	Cronbach α	Kolmogorov-Smirnov
MPT	(MCQ)	71.99	15	15	7	20	20	0.701	0.008
PyPT	(MCQ)	66.69	14	17	7	20	20	0.885	0.000

As Table 1 shows all tests demonstrated an internal consistency in a range from reliable to highly reliable as indicated by a Cronbach’s alpha coefficients (0.701–0.885).

Results

In the following sections, we present the detected misconceptions by analysing students’ mistakes related to programming concepts. To compare the effectiveness of using BPL for mediated transfer to TBPL, we compared students’ mistakes in C and E groups. To filter out random wrong answers, we decided to analyse wrong answers with a frequency rate of at least 10%. We categorized a frequency rate of 10%–20% as “frequent”, and a rate exceeding 20% as “fairly frequent”.

Analysis of Misconceptions Related to Variables and Sequencing Algorithm

A total of 8 multiple-choice question (MCQ) tasks were designed to assess students’ understanding of variables and sequencing algorithms. The incorrect answer options provided in the MCQs were based on previously detected misconceptions related to investigated concepts. Appendix B shows such tasks.

The analysis of misconceptions related to variables was based on the findings from several prior studies (Kohn, 2017; Žanko et al., 2019, 2022, 2023). Students’ mistakes were grouped according to previously identified misconceptions. Table 2. shows relation between wrong answers and appropriate misconception.

Table 2.

Misconceptions and Answers Related to the Variable and Sequencing Algorithm.

Since the data did not follow a normal distribution (Table 1), a non-parametric Mann-Whitney test was used to determine the differences in students’ results between groups. Test results showed statistically significant differences between E and C groups (U = 1180.500, p = .000). The E group achieved better results (mean = 7.26) compared to students’ results from the C group (mean = 4.26).

To further explore the differences between groups for each task, a chi-square (χ²) test was conducted. Table 3 shows the results.

Table 3.

χ² Test Results for Variables and Sequencing Algorithm Related Tasks.

	E_T1 - C_T1	E_T2 - C_T2	E_T3 - C_T3	E_T4 - C_T4	E_T5 - C_T5	E_T6 - C_T6	E_T7 - C_T7	E_T8 - C_T8
χ²	26.720	23.031	24.485	28.899	19.092	33.541	26.706	27.918
df	5	5	6	6	5	6	6	6
p	0.000	0.000	0.000	0.000	0.002	0.000	0.000	0.000

As Table 3 shows there were statistically significant differences between the groups for every task. Frequency rates of student answers were used to compare the differences in results between the groups. Figure 1 shows the comparison of misconceptions related to variables and sequencing algorithms between the E and C groups.

Figure 1.

Comparison of misconceptions related to variables and sequencing algorithms.

As Figure 1 shows, the experimental group not only achieved overall better results but also had a significantly lower rate of misconceptions compared to the control group. These findings suggest that the use of BPL for mediated transfer to TBPL can effectively reduce the occurrence of misconceptions associated with variables and sequencing algorithms.

Analysis of Misconceptions Related to the Selection Algorithm

A total of 6 multiple-choice questions (MCQ) tasks were designed to gauge students’ understanding of selection algorithms. The tasks were based on two programs: the first pertaining to the ‘if’ statement, and the second to the ‘if-else’ statement. Appendix C shows programs.

Prior research indicates that misconceptions related to selection algorithms are relatively infrequent (Žanko et al., 2023). However, despite their infrequency, several misconceptions were still detected. Notably, it was observed that the rates of selection misconceptions varied depending on whether the task involved a single ‘if’ statement or an ‘if-else’ statement. Table 4 presents the detected misconceptions and their frequency rates for the E and C groups.

Table 4.

Misconceptions Related to the Selection Algorithms.

Misconceptions	Statement	inputs	Task /Answers	C group	E group
M6	if	10	T9 / a) 10	13.70%	0.46%
Printing the input value		20	T10 / a) 20
Printing the input value		30	T11 / b) 30
M7	if	30	T11 / e) Nothing will print.	11.11%	13.70%
Misinterpretation of condition	if	30	T11 / e) Nothing will print.	11.11%	13.70%
M6	if-else	100	T12 / a) 100	11.11%	0.00%
Printing the input value		100
Printing the input value		128
M8	if-else	128	T14 / a) 128	16.11%	14.38%
Misinterpretation of the limit value of the condition	if-else	128	T14/d) I don’t see well!	16.11%	14.38%
M9	if-else	128	T14/e) Nothing will print	23.33%	12.33%
Ignoring else branch	if-else	128	T14/e) Nothing will print	23.33%	12.33%

The Mann-Whitney test was used to determine the differences in students’ results between the E and C groups. The test results showed statistically significant differences between E and C groups (U = 2048.000, p = .000), with the E group achieving better results (mean = 5.15) compared to the C group (mean = 3.92). To further explore the differences between groups for each task, a chi-square (χ²) test was conducted. Table 5 shows the results.

Table 5.

χ² Test Results for Selection Algorithm Related Tasks.

	E_T9 - C_T9	E_T10 - C_T10	E_T11 - C_T11	E_T12 - C_T12	E_T13 - C_T13	E_T14 - C_T14
χ²	22.943	17.279	13.718	18.536	19.996	13.531
df	5	5	5	6	6	6
p	0.000	0.004	0.018	0.005	0.003	0.035

As Table 5 shows there were statistically significant differences between the groups for each task. To compare the differences in results between the groups, frequency rates of student answers were analysed. Figure 2 shows the comparison of misconceptions related to selection algorithms between the E and C groups.

Figure 2.

Comparison of misconceptions related to selection algorithms.

Overall, it is evident that students have fewer problems with selection algorithm compared to the other two fundamental algorithms (sequence and loop). However, the experimental group once again achieved better results and a significantly lower rate of selection misconceptions compared to the control group.

The difference was most noticeable in the case of M8, particularly within the control group. Misconception M8 is notably more prevalent in scenarios involving single ‘if’ statement. Students may encounter difficulties in recognizing that a program might not produce any output, particularly when a print instruction is present, as in Program #1.

These findings further emphasize the effectiveness of using BPL for mediated transfer to TBPL in reducing misconceptions related to selection algorithms.

Analysis of Misconceptions Related to Loop Algorithm

A total of 6 multiple-choice questions (MCQ) tasks were designed to assess students’ understanding of loop algorithms. Appendix D shows tasks related to the loop.

The analysis of misconceptions related to loops was based on the findings from a prior study (Žanko et al., 2023) which also examined the combination of MakeCode and Python programming languages. Students’ mistakes were grouped according to previously identified misconceptions. Table 6. shows relation between wrong answers and corresponding misconception.

Table 6.

Misconceptions Related to the Loop Algorithm.

Misconceptions marked with an asterisk * (e.g., M1* M4*, M5*) were primarily related to variable misconceptions but were also detected in loop tasks.

The Mann-Whitney test was used to determine the differences in students’ results between the E and C groups. The test results revealed statistically significant differences between E and C groups (U = 928.500, p = .000), with the E group achieving better results (mean = 4.29) compared to the C group (mean = 1.97).

It is important to note that Python’s ‘for’ loop contains a peculiarity not found in other comparable languages. In Python’s ‘for’ loop, the <end > value is excluded from the range of iteration, unlike in MakeCode where it is included. Despite such differences, which can be confusing for students learning both languages, the E group achieved better results and exhibited fewer loop-related misconceptions.

To further explore the differences between groups for each task, a chi-square (χ²) test was conducted. Table 7 shows the results.

Table 7.

χ² Test Results for Loop Algorithm Related Tasks.

	E_T15 - C_T15	E_T16 - C_T16	E_T17 - C_T17	E_T18 - C_T18	E_T19 - C_T19	E_T20 - C_T20
χ²	33.885	43.988	25.010	41.590	50.090	20.433
df	5	5	5	5	5	5
p	0.000	0.000	0.000	0.000	0.000	0.001

As Table 7 shows, there were statistically significant differences for all loop-related tasks. To compare the differences in results between the groups, frequency rates of student answers were analysed. Figure 3 shows the comparison of misconceptions related to loop algorithms between the E and C groups.

Figure 3.

Comparison of misconceptions related to loop algorithms.

It is obvious that the C group gain higher number of loop-related misconceptions compared to the E group. These findings confirm that, despite possible difficulties in transferring knowledge from MakeCode to Python concerning the ‘for’ loop, the use of BPL for mediated transfer has a significant impact on reducing the number of detected loop-related misconceptions.

Discussion

This study is a continuation of research based on previous studies that addressed misconceptions (Mladenović et al., 2018; Žanko et al., 2019, 2022, 2023) and the challenge of transferring learned concepts between block-based programming languages (BPL) and text-based programming languages (TBPL) (Mladenović et al., 2021). The above studies are part of the broader research related to detecting programming misconceptions at the K-12 level which was conducted in four phases, with each next phase building on the findings of the previous phase. In the first phase, four basic misconceptions related to the variables in Logo and Python were identified (Žanko et al., 2019). In the second phase, we investigated the influence of visualisation on the understanding of the variables (Mladenović et al., 2020) and the occurrence of misconceptions (Žanko et al., 2022), identifying two additional misconceptions related to the variables. In the third phase, we investigated the effects of using MakeCode for micro:bit as a tool for mediated transfer to Python on the understanding of basic programming concepts such as sequencing, selection and repetition (Mladenović et al., 2021) and the occurrence of a total of 15 misconceptions related to the programming concepts taught (Žanko et al., 2023). The fourth phase described in this paper was an extension of the previous phase by removing or minimising the limitations of the study by increasing the number of participants and adding the control group. In addition, based on the results of the previous study, only the bridging method of mediated transfer is used in this study, as the bridging method proved to be significantly more successful compared to the hugging method (Mladenović et al., 2021).

In the following subsections, we discuss our findings in relation to the previously posed research questions.

RQ1: Does the Use of Block-Based Programming Language (BPL) for Mediated Transfer to Text-Based Programming Language (TBPL) Impact Students’ Programming Misconceptions for Fundamental Programming Concepts?

Although there is a growing body of knowledge investigating the transition issues from BPL to TBPL, there is a lack of such research examining the impact of this transition on misconceptions within TBPL. This study was structured based on the previous research that demonstrated the success of using mediated transfer pedagogical approach using the bridging method, especially when BPL was used to transfer to TBPL in both (a) mastering fundamental programming concepts in TBPL (Mladenović et al., 2021), and (b) decreasing known programming misconceptions in TPBL (Žanko et al., 2023). In this study, we set up a quasi-experimental study with the control (n = 90) and the experimental (n = 73) groups. The control group received programming lectures using the traditional approach with TBPL Python, while the experimental group started with BPL MakeCode and transitioned to TBPL Python by using the mediated transfer pedagogical approach as a bridging method. This study focused on assessing the impact of the emergence of misconceptions. The results showed that the experimental group gained statistically significantly fewer misconceptions across all fundamental programming concepts, including variables, selection, and loops. The rate of misconceptions in both groups is presented in Table 8.

Table 8.

Most Frequent Programming Misconceptions Found in the Study.

RQ2: What Are the Most Frequent Programming Misconceptions in Text-Based and Block-Based Programming Languages Among K-12 Students?

Programming misconceptions have been investigated since the 1980s (Bonar & Soloway, 1983, 1985; Du Boulay, 1986; Kurland & Pea, 1985; Mayer, 1981; Pea, 1986; Soloway et al., 1982; Spohrer & Soloway, 1986), when text-based environments were dominant. Since then, there have been substantial changes – technically, in programming environments, the age at which students begin programming, technological advancements, hardware prices, and so on. Still, it seems that despite such major changes, programming misconceptions have remained the same or similar (Alexandron et al., 2012; Brown & Altadmri, 2014; Kohn, 2017; Sirkiä, 2012; Sirkiä & Sorva, 2012; Sorva, 2018). Such consistency of common programming errors among novices suggests that programming is more of a cognitive and thinking skill than technical one.

In this study, we identified misconceptions that had been previously observed, taking into account the age of student, and designed programming lectures for the quasi-experiment with a focus on these misconceptions. We aimed to explore the possibility of decreasing the occurrence of misconceptions in TBPL Python after the use of BPLs. To filter out random errors, we defined rates of mistakes as follows: more than 20% was considered “fairly frequent”, 10%–20% as “frequent”, while the other (<10%) were considered as “rare”. Table 8 presents these findings.

As Table 8 shows, the control group developed a higher rate of misconceptions for most observed ones, with the exceptions of M7 and M13 where the difference between groups was negligible. It is also important to notice that in the experimental group, none of the misconceptions occurred at a frequent rate. In fact, most of them were rare (<10%). Generally, there were fewer misconceptions related to the selection algorithm (M6–M9), with a significant difference between experimental and control groups noted for M6 (printing the input value) and M9 (ignoring else branch).

The most frequent (>20%) misconceptions related to variables in the control group were M1 and M5, while the same misconceptions were either frequent (10%–20%) or rare (<10%) in the experimental group. Of the four loop-related misconceptions, only M11 was categorized as frequent in the control group and rare in the experimental group. M10, M12 and M14 were fairly frequent in the experimental group, and again frequent in the control group.

These findings provide valuable insights into the programming misconceptions among K-12 students and highlight the potential benefits of using BPL in mediated transfer to TBPL. These results have implications for the development of effective programming curricula that would address and mitigate misconceptions within a K-12 educational context.

Limitations of the Study

One notable limitation of our study is the fact that we were unable to conduct the qualitative research in a formal school setting. Due to limitations of the school settings, such as time constraints and curriculum requirements, qualitative data collection methods, such as interviews or observations, were not possible. However, it is worth noting that school setting provided us with a more realistic view of the challenges faced by teachers and students in their daily teaching, which contributed to the external validity of the study.

Our study focused primarily on the transition from block-based to text-based programming languages and may not have addressed all relevant factors that influence understanding of basic programming concepts at the K-12 level. Future research could explore additional variables such as teacher characteristics, instructional resources, and student demographic characteristics to gain a more comprehensive understanding of effective teaching practices in programming education.

Implications for Teaching and Future Work

Incorporating programming and computational thinking into national curricula has become imperative, reflecting the importance of these skills as essential for students in today’s digital age. However, the transition from BPLs, like Scratch or MakeCode, to TBPLs, like Python, presents challenges that educators must address to ensure effective learning outcomes. When designing programming lectures to transfer programming concepts between two environments educators should consider several strategies: (a) alignment of the programming paradigms in used environments. While BPLs typically follow functional or object-oriented paradigms, TBPLs, mostly follow procedural paradigms. By understanding these differences, educators can align their instructional approaches to facilitate the transfer of programming concepts and minimise programming misconceptions; (b) use BPL for mediated transfer to TBPL by making similar programming contexts in two environments to enable the transfer between them, (c) minimise programming misconceptions. Educators should design programming lectures with an awareness of common programming misconceptions and implement strategies to address and minimize them. Our findings confirmed that typical programming misconceptions can be minimised using the proposed approach.

Despite significant technological changes from the 1980s, the first detected programming misconceptions from the 1980s are still presented not just at the university level, but at the K-12 level also. This indicates that programming is more than just a technical skill—it is a cognitive skill that requires careful attention to pedagogical approaches. As a result, our next research will focus on high school and undergraduate studies to identify and compare novice programming misconceptions, further enhancing our understanding of effective teaching strategies in programming education.

Conclusion

The results of this study highlight the significant effectiveness of using BPL MakeCode within a mediated transfer pedagogical approach, employing the bridging method, for transitioning to TBPL Python in reducing programming misconceptions among K-12 learners. The experimental group, which experienced the transition from BPL to TBPL, demonstrated a statistically significant decrease in misconceptions related to fundamental programming concepts, including variables, selection, and loops. These findings emphasize the potential benefits of incorporating BPL as an initial step when introducing students to TBPL, thereby helping them build a solid programming foundation with fewer misconceptions.

Footnotes

Acknowledgments

We would like to express our appreciation to the students and teachers who participated in the study.

Declaration of Conflicting Interests

The author(s) declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Funding

The author(s) received no financial support for the research, authorship, and/or publication of this article.

Ethical Statement

ORCID iD

Monika Mladenović

Appendix

Appendix A.

Python pre-test tasks.

Appendix B.

Python post-test tasks related to variables and sequencing algorithm.

Appendix C.

Python post-test tasks related to selection algorithm.

Appendix D.

Python post-test tasks related to variables and loop algorithm.

Author Biographies

Dr. Monika Mladenović is an assistant professor at the Faculty of Science, University of Split (Croatia) in the Computer Science department. She teaches courses at the Computer Science department related to didactics of computer science and databases. She received her PhD in the interdisciplinary field of computer science and pedagogy at the Faculty of Science, University of Split. She is the head of the Computer science education research group. Her research interest includes the application of different didactic methods and technologies in teaching computer programming, including programming language choice, mitigating misconceptions in programming, mental models, and efficiency of algorithm visualization.

Dr. Žana Žanko is a mathematics and computer science teacher working in elementary school Mejaši in Split, Croatia since 2001. She received her PhD in the interdisciplinary field of computer science and pedagogy at the Faculty of Science, University of Split. Her research interest is misconceptions detection and appropriate techniques for mitigating them while teaching and learning computer programming at the K-12 level. She is a member of the Computer science education research group at the Faculty of Science, University of Split.

Dr. Goran Zaharija is an Assistant Professor at the University of Split, Faculty of Science, holding a PhD in Computer Science. He specializes in research on Artificial Intelligence, focusing on multiagent systems and exploring the intersections of AI with education and human cognition. As a committed educator, he teaches several graduate and undergraduate courses in web development, data science, and machine learning. He has contributed to several international research projects and is currently engaged in two ongoing initiatives. Actively participating in the IT community, he is involved in organizing programming courses for children and adults. He also regularly attends and presents at local ML/AI meetup groups.

References

Alexandron

Armoni

Gordon

Harel

(2012, November 15). The effect of previous programming experience on the learning of scenario-based programming. Proceedings of the 12th Koli calling international conference on computing education research. https://doi.org/10.1145/2401796.2401821

Ben-Ari

(2001). Constructivism in computer science education. ACM SIGCSE Bulletin, 30(1), 257–261. https://doi.org/10.1145/274790.274308

Bentz

Standl

(2023). Novice programmers conceptions of loops in K-12 education in consideration of interest and ability. Proceedings of the 18th WiPSCE Conference on Primary and Secondary Computing Education Research pp. (1–9). https://doi.org/10.1145/3605468.3605506

Bonar

Soloway

(1983). Uncovering principles of novice programming. Proceedings of the 10th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages pp. (10–13).

Bonar

Soloway

(1985). Preprogramming knowledge: A major source of misconceptions in novice programmers. Human-Computer Interaction, 1(2), 133–161. https://doi.org/10.1207/s15327051hci0102_3

Brown

N. C. C.

Altadmri

(2014, July 28). Investigating novice programming mistakes. Proceedings of the tenth annual conference on International computing education research. https://doi.org/10.1145/2632320.2632343

Chetty

Barlow-Jones

(2012). Bridging the Gap: The Role of Mediated Transfer for Computer Programming. Proceedings of the 4th International Conference on Education Technology and Computer (ICETC 2012), Cape Town, South Africa, 18 – 19 August 2012 (pp 1 -6). IPCSIT Vol. 43 (2012). ISBN 978-981-07- 2759-8.

Dann

Cosgrove

Slater

Culyba

Cooper

(2012). Mediated transfer: Alice 3 to Java. Proceedings of the 43rd ACM Technical Symposium on Computer Science Education pp. (141–146). https://doi.org/10.1145/2157136.2157180

Du Boulay

(1986). Some difficulties of learning to program. Journal of Educational Computing Research, 2(1), 57–73. https://doi.org/10.2190/3LFX-9RRF-67T8-UVK9

10.

Grover

Basu

(2017). Measuring student learning in introductory block-based programming: Examining misconceptions of loops, variables, and boolean logic. Proceedings of Science Education - SIGCSE the 2017 ACM SIGCSE Technical Symposium on Computer ’17, pp. (267–272). https://doi.org/10.1145/3017680.3017723

11.

Guzdial

(2004). Programming environments for novices. Computer Science Education Research, 111, 127–154.

12.

Kohn

(2017). Variable evaluation: An exploration of novice programmers’ understanding and common misconceptions. The 2017 ACM SIGCSE Technical Symposium (pp. 345–350). https://doi.org/10.1145/3017680.3017724

13.

Kölling

(2023). From blocks to professional development – thoughts on the future of educational programming. Proceedings of the 18th WiPSCE Conference on Primary and Secondary Computing Education Research (pp. 1–3). https://doi.org/10.1145/3605468.3609785

14.

Krishnamurthi

Fisler

(2019). Programming Paradigms and Beyond (pp. 377). The Cambridge Handbook of Computing Education Research.

15.

Krpan

Mladenovic

Zaharija

(2017). Mediated transfer from visual to high-level programming language. 2017 40th international convention on information and communication technology, electronics and microelectronics, MIPRO 2017 - Proceedings. https://doi.org/10.23919/MIPRO.2017.7973531

16.

Kurland

D. M.

Pea

R. D.

(1985). Children’s mental models of recursive Logo programs. Journal of Educational Computing Research, 1(2), 235–243. https://doi.org/10.2190/jv9y-5pd0-mx22-9j4y

17.

Lewis

C. M.

(2010). How programming environment shapes perception, learning and goals: Logo vs. Scratch. Proceedings of the 41st ACM technical symposium on Computer science education (pp. 346–350). https://doi.org/10.1145/1734263.1734383

18.

Mayer

R. E.

(1981). The psychology of how novices learn computer programming. ACM Computing Surveys, 13(1), 121–141. https://doi.org/10.1145/356835.356841

19.

Mladenović

Boljat

Žanko

Ž.

(2018). Comparing loops misconceptions in block-based and text-based programming languages at the K-12 level. Education and Information Technologies, 23(4), 1483–1500. https://doi.org/10.1007/s10639-017-9673-3

20.

Mladenović

Žanko

Ž.

Granić

(2021). Mediated transfer: From text to blocks and back. International Journal of Child-Computer Interaction, 29, 100279. https://doi.org/10.1016/j.ijcci.2021.100279

21.

Mladenović

Žanko

Ž.

Aglić Čuvić

(2020). The impact of using program visualization techniques on learning basic programming concepts at the K–12 level. Computer Applications in Engineering Education, 29(1), 145–159. https://doi.org/10.1002/cae.22315

22.

Mladenović

Žanko

Ž.

Boljat

(2019). Programming misconceptions at the K-12 level. In Tatnall

(Ed.), Encyclopedia of education and information technologies (pp. 1–13). Springer International Publishing. https://doi.org/10.1007/978-3-319-60013-0_234-1

23.

Pea

R. D.

(1986). Language-independent conceptual “bugs” in novice programming. Journal of Educational Computing Research, 2(1), 25–36. https://doi.org/10.2190/689t-1r2a-x4w4-29j2

24.

Qian

Lehman

(2018). Using technology to support teaching computer science: A study with middle school students. Eurasia Journal of Mathematics, Science and Technology Education, 14(12), em1610. https://doi.org/10.29333/ejmste/94227

25.

Resnick

Maloney

Monroy-Hernández

Rusk

Eastmond

Brennan

Millner

Rosenbaum

Silver

Silverman

Kafai

(2009). Scratch: Programming for all. Communications of the ACM, 52(11), 60–67. https://doi.org/10.1145/1592761.1592779

26.

Sirkiä

(2012). Recognizing programming misconceptions: Aalto University.

27.

Sirkiä

Sorva

(2012). Exploring programming misconceptions. Proceedings of the 12th Koli Calling International Conference on Computing Education Research ’12 (pp. 19–28). https://doi.org/10.1145/2401796.2401799

28.

Soloway

Ehrlich

Bonar

Greenspan

(1982). What do novices know about programming. In Badre

Shneiderman

(Eds.), Directions in Human-computer Interaction. Norwood.

29.

Sorva

(2018). Misconceptions and the beginner programmer (p. 171). Computer Science Education: Perspectives on Teaching and Learning in School.

30.

Spohrer

J. C.

Soloway

(1986). Novice mistakes: Are the folk wisdoms correct? Communications of the ACM, 29(7), 624–632. https://doi.org/10.1145/6138.6145

31.

Sun

Zhu

Ouyang

Cheng

(2023). Transitioning from introductory to professional programming in secondary education: Comparing learners’ computational thinking skills, behaviors, and attitudes. Journal of Educational Computing Research, 07356331231204653. https://doi.org/10.1177/07356331231204653

32.

Swidan

Hermans

Smit

(2018). Programming misconceptions for school students. Proceedings of the 2018 ACM Conference on International Computing Education Research ’18 (pp. 151–159). https://doi.org/10.1145/3230977.3230995

33.

Tabet

Gedawy

Alshikhabobakr

Razak

(2016). From alice to python. Introducing text-based programming in middle schools. Annual Conference on Innovation and Technology in Computer Science Education, ITiCSE, 11–13 July, 2016, pp. 124–129. https://doi.org/10.1145/2899415.2899462

34.

Vaníček

Dobiáš

Šimandl

(2022). Understanding loops: What are the misconceptions of lower-secondary pupils? Informatics in Education, 22(3), 523–554. https://doi.org/10.15388/infedu.2023.20

35.

White

(2001). Misconceptions in CIS education. Journal of Computing Sciences in Colleges, 16(3), 149–152.

36.

Žanko

Ž.

Mladenović

Boljat

(2019). Misconceptions about variables at the K-12 level. Education and Information Technologies, 24(2), 1251–1268. https://doi.org/10.1007/s10639-018-9824-1

37.

Žanko

Ž.

Mladenović

Krpan

(2022). Analysis of school students’ misconceptions about basic programming concepts. Journal of Computer Assisted Learning, 38(3), 719–730. https://doi.org/10.1111/jcal.12643

38.

Žanko

Ž.

Mladenović

Krpan

(2023). Mediated transfer: Impact on programming misconceptions. Journal of Computers in Education, 10(1), 1–26. https://doi.org/10.1007/s40692-022-00225-z