1. Introduction

For learners in Key Stage 3, many of them are encountering high-level programming languages (such as Python) for the first time. It is important that your disciplinary knowledge is built on strong foundations, to then begin exploring higher-level concepts, such as abstraction, algorithms, and data modeling, as you move into Key Stage 4 and beyond. The challenge faced is that programming is particularly prone to misconceptions, due to the new skills required of logical reasoning, syntactical accuracy, and abstract thinking. These misconceptions can often go unnoticed during KS3 and pose challenges for teaching programming at higher levels of education. These misconceptions range from one pupil to another. It could be ‘confusing assignment and equality’ (= or ==), ‘misunderstanding the use of colons and indentation’, or ‘struggling to follow the logical process of how to solve a problem’. These misconceptions are not simply gaps in knowledge but alternative models that pupils build when grappling with new content.

Effective teaching of computing must establish this disciplinary knowledge, but also anticipate and address these misconceptions in order to lead to a deep conceptual understanding. The National Centre for Computing Education emphasises the importance of structuring learning around key concepts and being aware of these common misconceptions to enhance pupil understanding. The misconception that I have chosen to tackle is around syntax errors in Python programming. After teaching a unit of Python programming earlier in the year, I observed the difficulties that KS3 pupils had when following the syntactical rules of a high-level programming languages like Python. I saw how I could plan these lessons around reinforcing these rules and addressing misconceptions to guide pupils towards a better understanding.

Focusing on syntax misconceptions supports my own professional development as a computing teacher, by challenging me to develop greater pedagogical subject knowledge (Schulman, 1986) by selecting pedagogical strategies that can make the abstract concepts more accessible to pupils. This aligns strongly with the Department of Educations Teachers’ Standards, especially ‘through the planning of well structured lessons tailored to the common learner needs (for Education, 2021). I value accessibility within Computing and believe that all pupils, regardless of prior exposure, should be able to create programs and solve problems confidently. This focus will make me more reflective about the assumptions that I hold, such as the idea that repeated coding practice alone is sufficient for pupils to understand syntax rules. These insights will shape the way I design lessons, and write activities, to create a safe classroom environment where misunderstandings are raised and discussed openly. In doing so, I am developing a more responsive and pupil-centred approach to teaching computing, and developing into a more effective teacher.

Our curriculum already uses some techniques, such as starter and retrieval quizzes (‘Do Now’) to reinforce this syntactical knowledge, which supports long-term retention and provides low stakes opportunities to correct misunderstandings. However, applying more pedagogical approaches through this study with pupils in KS3 will put them in stronger and more confident position going into their GCSE qualification, providing more time to focusing on developing skills rather than reteaching core programming concepts.

2. Literature Review

Programming errors pose significant challenges for beginner programmers. Syntax errors, mistakes in code structure, prevent programs from running, causing frustration among learners (Senecca, 2025). Python is the predominant language in programming education at KS3 and KS4 (King’s, 2024) and this essay examines the misconceptions surrounding syntax rules in Python and explores pedagogical techniques to address these misconceptions.

The prevalence of syntax errors among beginner programmers can be attributed to a combination of cognitive overload and the abstract nature of programming syntax, contrasting with natural language constructs (Sweller, 1988). Cognitive load theory suggests that learners have limited working memory capacity. When faced with complex programming tasks, learners may become overloaded, making them more prone to overlooking syntactical details, like correct punctuation or the precise order of operations. This overload can manifest as syntax errors, These errors are not always because the learner doesn’t understand the rules, but because their cognitive resources are stretched thin. This highlights the need for pedagogical techniques to tackle these misconceptions.

2.1 Syntax Errors

Understanding and correcting syntax errors is a major hurdle for novice programmers, especially at the KS3 level where learners are often encountering text-based languages for the first time. Research shows that syntax errors are among the most frequent and frustrating issues that beginner programmers face (Robins et al., 2003). These errors can include incorrect indentation, missing colons, or inconsistent use of capitalisation. Errors like this can hinder a learner’s sense of progress and cause them to disengage, if the errors are not addressed effectively through instruction and support.

One of the reasons that syntax errors are so persistent is because beginner programmers lack a mental model of how a programming language is structured. This parallels the way that pupils struggle picking up English and spelling when they first start in Primary school. Du Boulay, 1986 argues that novice learners must develop both “notational machines” (a conceptual model of how the code executes) and syntactical fluency in order to write functional programs. Without this foundational understanding, learners often resort to guesswork, building their own model about how it work, which can lead to embedded misconceptions. Sentance and Csizmadia, 2016 extend this idea, arguing that introducing syntax in visually scaffolded contexts can help reduce barriers. This could be using block-based environments such as Scratch that abstracts away some of the syntax concerns for beginner programmers.

Grover and Basu (Grover and Basu, 2017) advocate for the use of pedagogical strategies such as live modelling and pair programming to support syntax development. Modelling allows teachers to explicitly show not only the “what” by the “why” behind correct syntax, whilst pair programming encourages learners to verbalise and reflect on their understanding with their peers. These pedagogical approaches are especially effective when combined with real-time teacher feedback, as they help pupils internalise syntax patterns and learn from their mistakes collaboratively. I have looked at these two commonly used pedagogical techniques, Paired Programming and Modelling. These techniques are evidenced by well-known institutions (“Engaging learners through pair programming - Teach Computing”, 2025) (“Modelling the programming process 4 through live coding - Teach Computing”, 2025).

2.2 Paired Programming

Paired programming offers a structured approach to collaborative learning, aiming to mitigate the cognitive overload often experienced by novice programmers who encounter complex syntax. By assigning distinct roles, the “driver” who writes the code and the “navigator” who reviews and guides, the task is broken down. This division of the task allows the learners to focus on one task, reducing the mental effort required to simultaneously manage syntax, logic, and problem solving. This “collective working memory effect” (NCCE, 2021) can be particularly beneficial when tackling syntax errors, as the navigator can provide immediate feedback and catch errors.

Constructivist learning theory, as proposed by Vygotsky (Vygotsky, 1978), suggests that learners actively construct understanding through social interaction. Paired programming aligns with this by providing structured opportunities for dialogue, feedback, and collaborative problem solving. It supports Vygotsky’s Zone of Proximal Development (ZPD), where learners develop skills through guidance and support from peers.

McDowell et al., 2002 reported a 15% increase in post-test performance in undergraduate computer science students using paired programming. Similarly, Williams and Kessler, 2000 found that code produced in pairs had fewer logical and syntactical errors and was completed more quickly. Although these studies focus primarily on higher education, recent research by Sentance et al., 2019 within UK secondary schools has shown that pupils engaged in pair programming showed improved engagement and understanding of programming constructs, particularly with younger learners aged 11–14.

There are a number of challenges that are faced by an educator in executing an effective paired programming activity (Techiebytess, 2024). Poor communication between partners can eliminate the benefits of the ‘collective working memory effect’. Miscommunications can increase the number of code faults and syntactical mistakes, rather than reducing them. The other complication is navigating the skill disparity that exists within a class. Lower attainment pupils may over-rely on higher attaining pupils. Some pupils may feel “overshadowed or left behind” which is why pupils should be paired up in a considered way.

Additionally, some students may thrive in more independent learning environments. Reflective learners, for example, might prefer to work through coding problems at their own pace and engage in self-directed debugging, rather than collaborating in real-time. It is important to consider the individual needs of each class and how they learn best.

Moreover, many studies on paired programming rely on self-reported data, such as perceived confidence and frustration levels. These subjective metrics can be influenced by social desirability bias, where students present positive feedback to please teachers or researchers. More objective data, such as the number and type of syntax errors in submitted code, time taken to complete tasks, or improvements over time, can provide a clearer picture of its effectiveness (Umapathy and Ritzhaupt, 2017).

In summary, paired programming, when implemented thoughtfully, offers significant promise in helping KS3 pupils develop syntactical accuracy and confidence. However, its success depends on 5 carefully designed activities, strategic pairing, and a classroom culture that supports both collaboration and individual reflection. These considerations will become important when I try to implement it myself in my own classroom.

2.3 Modelling

It is important to consider the role of the teacher in supporting novice programmers. Modelling is an increasingly recognised pedagogical strategy in computing education, particularly when support practical tasks with pupils at Key Stage 3. By making expert thinking visible, modelling helps pupils understand both the structure and reasoning behind the code they are writing, addressing the challenge of learning new syntax and syntax languages.

When implemented effectively, modelling can be a teacher led approach that involves demonstrating coding practices and includes the identification and correction of syntax errors in real time. A teacher may employ a number of techniques to emulate syntax errors, such as intentionally making mistakes to prompt pupils with. This is a supported technique across the literature. In this paper, academics at the University of Sussex, identify the importance of using modelling (via worked examples) as a technique to teach programming (Soraya et al., 2010). Teachers modelling code in real time can expose pupils to authentic debugging practices and encourage a growth mindset around error correction. This is especially relevant when discussing KS3 pupils, who are encountering Python and the syntax of text-based programming for the first time. Studies show that they will benefit from the explicit instruction and interrogation aspects of modelling programming.

This community thread discusses the application of modelling syntax errors “in particular, show them what happens when you make a syntax error” (Various., n.d.). While the online community thread offers anecdotal insights into the use of modelling syntax errors, it lacks the rigour of peer-reviewed research. The advice is based on individual experiences and may not be applicable to all learners or contexts.

Modelling also helps to overcome the “syntax barrier” described by Robins et al., 2003, whereby learners became fixated on avoiding errors rather than understanding the underlying concepts. When teachers model how to respond to errors, it can shift pupil’s perspective of mistakes and lead to a positive classroom culture where errors can be discussed openly.

Modelling support the cognitive apprenticeship theory, in which learners acquire new skills through guided experience (Collins et al., 1988). In Computing, this involves the teacher acting as an expert programmer, demonstrating problem-solving processes and gradually releasing responsibility to learners. For KS3 pupils, this structured support can be particularly helpful when introducing unfamiliar syntax, such as indentation, use of colons, or variable naming conventions.

Overall, the literature supports modelling as a high-impact strategy for programming instruction. It helps understand code, builds confidence, and enables learners to internalise good habits, providing a foundation for more independent and error-resilient programming in future stages of learning.

2.4 Summary

A review of the literature highlights that beginner programmers frequently struggle with syntax errors, particularly issues like incorrect indentation, case sensitivity, and punctuation. These errors can significantly hinder learners’ progress and confidence. Research also emphasises the importance of explicitly modelling programming processes, which helps to demystify code structure and reduce misconceptions. Modelling supports cognitive load reduction by making abstract concepts concrete and giving learners the chance to observe and understand expert thinking . In parallel, paired programming is shown to encourage collaboration and engagement, reducing cognitive load through the “collective working memory effect” and improving accuracy through peer support (McDowell et al., 2002). While each strategy presents implementation challenges, such as communication issues or learner preferences for independent work, the consensus across the literature supports their use to enhance novice programmers’ fluency and confidence. These insights directly informed the pedagogical choices in my intervention, shaping the design of a KS3 unit intended to address syntax misconceptions in a practical and engaging way.

3. Application of Research to Teaching

In addressing syntax misconceptions, I have drawn upon my two research informed strategies of modelling and paired programming to enhance pupil understanding and engagement. The unit of work was structured around Python Turtle, providing a visually engaging and purposeful context for programming. Creating geometric shapes (such as rectangles, diamonds and circles) offered a clear and predictable program flow.

Creating a rectangle
Draw a line down
Turn left
Draw a line across
Turn left
Draw a line up
Turn left
Draw a line across

Pupils could follow the steps in the program by drawing the shape themselves on paper, reducing the level of abstraction needed for the activities. This helped to make the abstract syntax of Python more concrete, reducing the Cognitive load and supporting the development of procedural understanding, a key concept for beginner programmers (Sweller et al., 2011). To deliver this unit, I used Trinket.io, a browser-based coding platform that includes both a text-based Python mode and a block-based mode. This choice as significant, as it enabled me to bridge pupils’ prior experiences with block-based programming tools (such as Scratch) with the new challenges of writing in a text-based language. This aligns with research by Grover and Basu, 2017, who argue that transitioning from block-based to text-based programming requires scaffolded support and a meaningful progression model. Many of the core concepts (such as loops, and variables) could be demonstrated and experienced in the block-based environment. When pupils feel confident with these concepts, the lesson would switch to a text-based environment and the focus can shift to the syntax misconceptions.

Modelling would play a crucial role throughout the unit within the teaching episodes. I employed the principles of cognitive apprenticeship (Collins et al., 1988) by verbalising the reasoning behind each line of code, allowing pupils to see how programmers approach debugging and syntax correction in real time. Intention mistakes can be employed to pose questions to pupils for real-time formative assessment and checking the current status of the misconceptions.

In the independent activities, Pair Programming would be applied to support collaborative learning during the activities held in the text-based environment of Trinket. Pupils would be paired up using a pre-defined seating plan based on their confidence level. One pupil would act at the “driver” and one pupil would act as the “navigator” and they would write and review code together. Supported by the research, this method helps to build confidence in programming amongst pupils, and encourages pupils to identify syntax mistakes themselves leading to that deeper understanding.

The Lessons

A six-lesson unit was designed to progressively build the pupil’s understanding of programming concepts, whilst addressing misconceptions and reducing the cognitive load demands typically associated with syntax learning. The lesson sequence was informed by the Cognitive Load Theory (McDowell et al., 2006) and the principles of scaffolded learning. There would be periods of self-reflection throughout the six lessons, which would act as formative assessment to form the pairings during the paired programming activities. If successful, this unit would lead to pupils feeling confident and fluent in their block-based and text-based programming.

The first lesson reintroduced pupils to block-based programming, providing a low-threshold entry point for starting the topic. It built on pupils prior experience with Scratch in Year 7 and primary school. This lesson focused on the concept of ‘sequencing’ showing pupils how to order instructions to build simple shapes, such as rectangles, diamonds, and triangles. In lesson two, more key programming concepts were introduced inside of the block-based environment, such as ‘iteration’ and ‘variables’. These lessons embedded these concepts and encouraged computational thinking, but in a familiar programming environment and with tasks that they could visualise clearly.

Modelling was used throughout showing pupils how to create a simple shape (rectangle) by dragging and dropping blocks together in the right order. Cold calling was introduced alongside the demonstrations, to identify any new or prior misconceptions before moving on. In lesson three, the same programming challenges were re-contextualised using a text-based programming environment, using Python Turtle. The shift was carefully planned with deconstructed comparisons showing the action, the block-based version and the text-based version. This helped to bridge the gap between the tasks set in the block-based environment to the new text-based language. Keeping the tasks similar helped pupils to focus on re-applying the skills in a different concept, rather than feeling overwhelmed and unsure. Grover and Basu, (2017) emphasise the importance of this type or transitional scaffolding to ease the jump from block to text-based programming.

Through the teaching episodes centred around modelling the new language, syntax errors could be shown and discussed through class discussion. This first lesson focused on the common mistakes such as capitalisation, incorrect indentation and misuse of brackets. During the independent activity, I could circulate and spot these errors when they occurred and challenge pupils to explain what the mistake was and how they would fix it, on a 1 to 1 basis.

Lesson four and five were dedicated to pair programming, encouraging pupils to support each other in using correct syntax. The apply tasks were more complex in nature, asking pupils to now combine shapes together to create a larger design. These activities gave pupils the ability to verbalise their thinking and collaboratively resolve errors. Through this verbalisation, I could also easily identify errors and misconceptions based on what the pupils were saying. Drawing from research on collaborative learning (Vygotsky, 1978; McDowell et al., 2006), this approach provided both cognitive and emotional support, and the informal feedback from their partner, increased their confidence and accuracy in syntax by the end of the lesson.

Lesson six brought everything together into a fun activity that I could go around and assess. Pupils applied their skills independently to design a number of national flags using Python Turtle. I used modelling to show them how to create an easier flag and then encouraged them to try more complicated flags. This open-ended task allowed me to see all the skills covered, such as ‘sequencing’, and ‘iteration’ and the success of the design wound indicate that there were no syntax errors in their code.

4. Methodology

To evaluate the effectiveness of my project in addressing syntax misconceptions in Python at KS3, I adopted a practitioner inquiry approach, supported by structured self-reflection and formative assessment data. Being a reflective teacher, gives us the opportunity to improve practice through self-awareness, respond to our pupils needs and bridge the gap between theory and practice. My project is supported by literature, and clearly through out but the reflection gives me a chance to reflect on the successes and identify improvements that need to be made. I sought a reflective framework that supports continuous learning and improvement within the classroom, rather than one reliant on formal assessment, such as marked pupil work.

The reflective model chosen for this inquiry is Gibbs’ Reflective Cycle (1988), which offers a structured yet flexible approach to post-lesson reflection. Gibbs’ reflective model is particularly well-suited as it encourages cyclical thinking through six key stages: Description, Feelings, Evaluation, Analysis, Conclusion and Action Plan. This framework promotes deep engagement with my teaching practice, encouraging critical reflection on both emotional and pedagogical dimensions of a lesson. The emotional side is especially important for my reflections, as I complete lessons with a resounding emotional response about how successful I feel the lesson was or how well the pupils responded to the material.

One of the key strengths of Gibbs’ model is that it supports reflective practice even without formal graded work, as it focuses on the teachers’ lived experience, pupil responses and observed learning behaviours (Finlay, 2008). This made it particularly appropriate within the context of my lessons, where I had access to to formative assessment data rather than a summative, marked portfolio of evidence.

Following each lesson in the unit, I engaged in a structured reflection using Gibbs’ six stages. I documented what occurred during the lesson (Description), how I felt it went (Feelings), and my initial judgements about its success (Evaluation). I looked at why certain misconceptions persisted or were resolved, using evidence from classroom dialogue, coding outputs, and the types of syntax errors pupils made (Analysis). This led me to identify key learning points and decide on next steps for future lessons (Action Plan). This iterative process mirrors Sch¨on, 1983 concept of the “reflective practitioner”, where teaching in continually refined in response to the in-classroom experience.

I did collect some qualitative and quantitive data from several sources to support my reflections.

• R-A-G Self-Assessment data from pupils was gathered at the mid-point (before starting the text-based programming) and the end of the unit. Pupils assessed their confidence against key learning points from the topic. This allowed me to track changes in pupil’s confidence over the course of the unit.
• Attainment grades using the schools levelling system. This offered a summative assessment of the pupils proficiency in the topic, but was based on a marking band rather than a score. For example, 0 would be “Does not apply themselves in the lesson, and have shown no development of skills” whereas 5 would “Applies themselves to all tasks to completion and in most cases goes beyond what is expected”.
• Lesson observations and feedback from mentors and visiting staff provides an external insight into the classroom climate, engagement and effectiveness. These qualitative comments support my own reflections over the course of this unit.


Together this data will provide a number of different perspectives about the effectiveness of this project. These approaches align with the action research ethos, where the teacher is both practitioner and researcher, engaging in reflection for their own professional development (McNiff and Whitehead, 2006). It also supports the development of reflective capacity, an essential characteristic of effective computing teachers.

5. Critical Evaluation

5.1 Results

This section presents key findings that were gathered through reflective journaling using Gibbs’ Reflective Cycle (1988), pupil self-assessment (RAG ratings), attainment grades, and feedback from lesson observations. The Data was collected across a six-lesson unit designed to address misconceptions in Python Syntax using strategies, such as pair programming and modelling. One of the most notable trends in the data was the increase in pupil confidence and attainment after working in pairs on Python programming tasks. This mirrors the work of McDowell et al., 2006 who found that pair programming not only improves program correctness but also enhances pupil retention and self-efficacy. In my own classroom, this was reflected in the R-A-G data: at the midpoint of the unit only 29% of pupils self-assessed as “green” for ‘I can use iteration to make my programs simpler’; by the end of the unit, this had increased to 59% and the remaining 18% assessed themselves as “Amber”. (The remaining percentage was pupils who were absent on the final lesson).

The use of modelling as a teaching strategy proved highly effective in clarifying complex syntax rules, as can be seen throughout my reflections. Research by Collins et al., 1988 on cognitive apprenticeship emphasises the importance of modelling expert thinking. In my own practice, I modelled writing and debugging code with live narration, drawing attention to common mistakes such as forgetting colons after control statements or misalignment of indentation. This approach resonates with Rosenshine’s (2012) principles of instruction, particularly “presenting new material in small steps” and “providing models”.

Observation feedback supported the success of these lessons and pedagogical approaches. One observer noted: “The use of pair programming was an effective way to help students understand the concept being taught”. This supports the ore strategy of this project, showing that pair programming enabled pupils to engage in collaborative dialogue and troubleshoot syntax errors together.

The observations highlighted the effective classroom management that went alongside the pedagogical approaches, with one observer saying “. . . actively circulated the room to check students’ progress and understanding, which is great. This shows the conscious effort I made to circulate a gather observable data to reflect upon after the lesson, as well as provide 1 to 1 support and monitor progress.

Observation feedback indicated that pupils were more engaged during pair programming tasks, with one observer noting that “collaboration helped reduce syntax errors, especially for pupils who lacked confidence.” This aligns with the literature on the benefits of collaborative learning in computing. My own reflections supported this observation. In Lesson 4, I wrote that “these ‘active discussion’ aspects helped pupils connect with error messages and find faults within their own code,” highlighting the metacognitive benefits of having a partner to think aloud with.

By Lesson 5, I had refined the structure of pair programming, implementing timed role switches and modelling of the driver/navigator roles, which I noted helped “ensure that pupils got started in their roles immediately.” This improved classroom management and ensured a more equal distribution of cognitive effort, helping to eliminate the “passivity” I had seen among weaker navigators in Lesson 4. These iterative improvements show how reflective practice helped me respond to barriers in real time.

Similarly, my reflections revealed that by Lesson 3, I had adapted my modelling approach to scaffold syntax more clearly, based on observed pupil difficulties. I had initially felt “slightly anxious about introducing text-based syntax” but later noted how “pupils responded positively” and that modelling helped them “bridge the transition from blocks to code.” I recognised that “syntax issues did occur (e.g., incorrect indentation or forgotten colons), but pupils were increasingly able to debug these,” echoing the findings of Becker et al. (2016), who stressed the importance of teaching learners to make sense of error messages.

By Lesson 6, this scaffolding had paid off. I observed that pupils “asked far fewer questions related to syntax” and that “debugging was mostly independent.” Pupils demonstrated improved fluency in the Python programming language, specifically in ‘sequencing’ and ‘iteration’, avoiding misconceptions like improper use of indentation and capitalisation errors.

5.2 Discussion

My findings support Grover and Basu, 2017, who found that structured transitions from block-based to ext-based programming reduce learner anxiety and improve code accuracy. However, Grover and Basu, 2017 observed significant performance dips when moving between blocks and text which wasn’t observed in my own observations. The use of Trinket.io’s block & text features appeared to smooth the transition. Pupil comments throughout the lessons indicated that they used the toggle-feature to switch from seeing Python text to Python blocks, if they got stuck. This helped them understand the logic of the program and then apply that to their own work. This suggests that carefully chosen tools can actually have a mitigating impact on some of the conceptual barriers identified in the broader literature.

The success of pair programming in reducing syntax errors echoes the work of McDowell et al., 2006, who showed improved performance and confidence among novice programmers. Pupils were similarly observed to engage more critically with their code when working collaboratively. Rather than relying solely on teacher intervention, pairs supported one another in identifying and correcting syntax errors, often talking through the logic of the code aloud. This aligns with Vygotsky’s theory of social constructivism, whereby knowledge is co-constructed through dialogue and interaction (Vygotsky, 1978). The driver-navigator roles in pair programming encourage these social aspect of developing programming skills, and peer feedback helps to reinforce correct syntax. Similar to the observations of Sentance and Csizmadia, 2016, pupils in my study benefited from visual contexts (e.g. Python Turtle), which made abstract syntax rules more concrete. They argued that visualisation and context-rich tasks support students in understanding how individual lines of code relate to the program flow and structure. In my lessons, this was particularly evident using modelling to demonstrate drawing rectangles, other shapes or the flag task in the final lesson. This approach also helped to reduce cognitive load associated with interpreting programming syntax without context.

I observed that case sensitivity errors these diminished rapidly once modelling and the pair programming pedagogues were introduced. In early lessons, I observed pupils writing ‘IF‘ rather than ‘if‘ or leaving a space before the brackets. However, by the end of the fourth lesson, these mistakes had reduced significantly. This improvement may be attributed to the consistent repetition of modelling examples, and the collaborative feedback aspect of pair programming. Some pupils in the class used these error messages as effective prompts to improve their code, particularly when paired up with a partner to discuss it with. As described in my reflective journal, this is due to the effectiveness of the modelling teaching episodes in lessons 1 - 3, that identified syntax mistakes and showed pupils how the errors occur and how to debug them.

5.3 Implications

These results suggest that future KS3 programming curriculum content should be carefully structured to include regular opportunities for both pair work and live teaching modelling. These strategies appear to be effective when introducing higher-level programming concepts, such as loops, or when pupils are confronted with new syntactical rules that differ from their prior experience in block-based languages. By embedding collaboration at key transition points in the learning cycle, practitioners can reduce cognitive overload and the likelihood of syntax errors, as learners are supported both by their peers and by teacher-led examples.

Alongside this study, it has shown the effectiveness of using tools like Trinket.io to bridge the block-based content from KS2 into the text-based content of KS3. Trinket’s ability to integrate both block and text modes provides an ideal scaffolding tool for bridging the gap in learner understanding. For pupils unfamiliar with Python syntax, being able to preview the underlying code while manipulating blocks gives them a contextualised understanding of commands, formatting, and structure. This aligns with the research around dual coding theory (Paivio, 1991), which suggests that combining visual and textual representations can improve understanding and retention. The decision to use Trinket was also rooted in a desire to reduce barriers to entry for less confident learners, ensuring all pupils could begin writing meaningful code from the outset of the unit.

Through the consistent application of Gibb’s Reflective Cycle (1988), I became a more responsive teacher, addressing misconceptions as they emerged, particularly by anticipating potential mistakes identified by others in the literature. This structured process enabled me to reflect systematically on each lesson, examining not only what went well, but also what could be improved, particularly in relation to persistent misconceptions. In doing so, I became more proactive in identifying potential misconceptions, such as indentation errors or misunderstanding the use of colons, before they occurred in the classroom. Drawing on insights from classroom observers and pupil R-A-G assessments, I was able to refine my explanations and adjust lesson pacing, which helped to better support pupils who were struggling. These reflections also encouraged me to test different styles of teaching, including more real-time coding examples and strategic use of questioning to assess understanding mid-lesson.

My understanding of the connection between conceptual understanding and syntactical knowledge in programming has deepened significantly throughout this project. I now better appreciate how a pupil’s grasp of high-level constructs like iteration or sequencing is often undermined by their uncertainty over basic syntax. This reinforces the perspective articulated by Schulman, 1986, who argues that effective teaching relies not only on knowing the subject matter, but also on understanding how best to convey it to learners. By integrating modelling, I was able to tailor my instruction to anticipate areas of confusion. This process has enhanced my pedagogical content knowledge (PCK), giving me a more nuanced understanding of how computing concepts should be sequenced, modelled, and assessed.

5.4 Evaluation

This project was successful in improving both pupil confidence and attainment in Python syntax. Data suggests that modelling and pair programming worked together to tackle common misconceptions and build confidence.

Limitations This study was completed over a short time-scale (six lessons) and with one class. Broader conclusions about the success of these pedagogical approaches would require implementation across multiple classes, school contexts and over a longer timeframe. The self-assessment data collected by the pupils’ R-A-G ratings, while useful, may contain bias due to over (or underestimation) by pupils.

Future Work Other strategies could be implemented alongside these to help further tackle syntactical mistakes. Using starter activities to focus on errors and how to solve them could reinforce pupils about how to approach an error in their syntax. The choice of IDE can also greatly help to tackle syntax by having auto-completion, syntax highlighting and syntax feedback. Some academics have suggested the implementation of auto-marking tools and code tracing exercises to further diagnose misconceptions that could be implemented on a future unit.

Conclusions

This reflective study has deepened my understanding of how to effectively teach programming to Key Stage 3 pupils transforming me into a more effective teacher of computing. I’ve done this by addressing common misconceptions around syntax rules. Through a structured six-lesson sequence grounded in research supported pedagogical approaches, I explored how modelling and paired programming can work together to support both conceptual and procedural knowledge. Beginning with block-based environments allowed pupils to follow modelled instructions and develop computational thinking skills without being hindered by the overall rules of syntax, aligning with cognitive load theory and a dual coding approach. As pupils transitioned to text-based programming, the live modelling and pair programming activities taught pupils how to write and debug code. My reflections from lesson 3 highlighted how “modelling helped bridge the transition from blocks to code” and this pedagogical approach created confidence in pupils for the longer activities at the end of the unit.

The use of pair programming developed the pupil’s syntactical knowledge through deliberate practice, scaffolding and peer dialogue, I observed that “collaboration helped reduce syntax errors” and that pupils engaged in more purposeful discussions, while working together. This aligns with theory around the collective working memory effect and supports the constructivist approaches to learning, which stress the importance of interaction and co-construction of knowledge. By lesson 5, my implementation was more structured around role-switching to ensure balanced participation from all pupils.

Throughout this unit, I applied Gibbs’ Reflective Cycle to refine my practice in real time. For example, after noticing in lesson 2 that verbalising programming concepts led to faster understanding, I created more opportunities for discussion in subsequent lessons. Similarly, after identifying unequal participation in lesson 4, I revised my pair programming routines in lesson 5 to ensure more equal engagement. These reflective adjustments, show how I transforming into a reflective and responsive teaching of computing, significantly improving the quality of learning and outcomes for my pupils.



Sources

• Collins, A., Brown, J. S., & Newman, S. E. (1988). Cognitive apprenticeship. Thinking: The Journal of Philosophy for Children, 8, 2–10. https://doi.org/10.5840/thinking19888129
• Du Boulay, B. (1986). Some difficulties of learning to program. Journal of Educational Computing Research, 2, 57–73. https://doi.org/10.2190/3lfx-9rrf-67t8-uvk9
• Engaging learners through pair programming - Teach Computing. (2025). https://teachcomputing. org/blog/engaging-learners-through-pari-programming
• Finlay, L. (2008, January). Reflecting on ’reflective practice’. Open Research Online. https://oro. open.ac.uk/68945/1/Finlay-%282008%29-Reflecting-on-reflective-practice-PBPL-paper- 52.pdf
• for Education, D. (2021). Teachers’ standards. GOV.UK. https://assets.publishing.service.gov.uk/ media/5a750668ed915d3c7d529cad/Teachers standard information.pdf
• Grover, S., & Basu, S. (2017). Measuring student learning in introductory block-based programming. Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education. https://doi.org/10.1145/3017680.3017723
• King’s. (2024). Programming education in England’s secondary schools. https://www.kcl.ac.uk/ programming-education-in-englands-secondary-schools
• McDowell, C., Werner, L., Bullock, H., & Fernald, J. (2002). The effects of pair-programming on performance in an introductory programming course. Proceedings of the 33rd SIGCSE technical symposium on Computer science education - SIGCSE ’02. https://doi.org/10.1145/563340.563353
• McDowell, C., Werner, L., Bullock, H. E., & Fernald, J. (2006). Pair programming improves student retention, confidence, and program quality. Communications of the ACM, 49, 90–95. https: //doi.org/10.1145/1145287.1145293
• McNiff, J., & Whitehead, J. (2006). All you need to know about action research. Sage Publications. Modelling the programming process through live coding
• Paivio, A. (1991). Dual coding theory: Retrospect and current status. Canadian Journal of Psychology / Revue canadienne de psychologie, 45 (3), 255–287. https://doi.org/10.1037/h0084295
• Robins, A., Rountree, J., & Rountree, N. (2003). Learning and teaching programming: A review and discussion. Computer Science Education, 13, 137–172. https://doi.org/10.1076/csed.13.2. 137.14200
• Sch¨on, D. A. (1983). The reflective practitioner. Routledge.
• Schulman, L. S. (1986). Those who understand : Knowledge growth in teac
hing. Ceras, School of Education, Stanford University.
• Senecca. (2025). Syntax errors - computer science. https://senecalearning.com/en-GB/revision- notes / ks3 / computer - science / national - curriculum / 2 - 1 - 19 - syntax - errors (accessed: 23.02.2025).
• Sentance, S., & Csizmadia, A. (2016). Computing in the curriculum: Challenges and strategies from a teacher’s perspective. Education and Information Technologies, 22, 469–495. https: //doi.org/10.1007/s10639-016-9482-0
• Sentance, S., Waite, J., & Kallia, M. (2019). Teaching computer programming with primm: A sociocultural perspective. Computer Science Education, 29, 136–176. https://doi.org/10.1080/08993408.2019.1608781
• Soraya, S., Rahman, A., & Du Boulay, B. (2010). Learning programming via worked-examples. Retrieved May 4, 2025, from https://users.sussex.ac.uk/∼bend/papers/ppig2010siti.pdf
• Sweller, J. (1988). Cognitive load during problem solving: Effects on learning. Cognitive Science, 12 (2), 257–285. https://doi.org/https://doi.org/10.1207/s15516709cog1202\ 4
• Sweller, J., Ayres, P., & Kalyuga, S. (2011). Cognitive load theory. Springer New York. https : //doi.org/10.1007/978-1-4419-8126-4
• Techiebytess. (2024, March). Overcoming Challenges In Pair Programming: A Comprehensive Guide raquo; Techiebytess.com. https://techiebytess.com/challenges-in-pair-programming
• Umapathy, K., & Ritzhaupt, A. D. (2017). A meta-analysis of pair-programming in computer programming courses. ACM Transactions on Computing Education, 17, 1–13. https://doi.org/10.1145/2996201
• Various. (n.d.). How to teach beginning students how to find and fix syntax errors? https://cseducators.stackexchange.com/questions/3485/how-to-teach-beginning-students- how-to-find-and-fix-syntax-errors
• Vygotsky, L. (1978). Mind in society. Psychological Medicine, 11. https://doi.org/10.1017/s0033291700041507
• Williams, L. A., & Kessler, R. R. (2000). All i really need to know about pair programming i learned in kindergarten.

This Ambassador Project focused on transforming departmental data practices to improve pupil outcomes while simultaneously reducing teacher workload. By implementing diagnostic assessment and automated feedback systems across Key Stages 3 and 4, the project successfully streamlined administrative processes, returning valuable planning time to educators, and provided teachers with precise, data-driven insights to help students bridge specific learning gaps.