Most students find programming a challenge. The progression and delivery of this scheme has been developed as a result of 25 years experience teaching teenagers to code. We’ve tried many methods, and this approach is by far the most successful.
This scheme introduces subprograms from the very first, “Hello World” program. Partly for progression from Key Stage 3, partly because it helps with problem decomposition, partly because structured programming is essential for Key Stage 4 and mostly because students don’t use subprograms unless they are very comfortable with them. Passing parameters and returning values is not easy for students to comprehend, so lots of practice, even with simple programs helps enormously. It is a mistake to leave subprograms until later in a scheme. That doesn’t make them easier. Practice makes them easier!
Although many of the concepts such as inputs, outputs, selections and condition-controlled iterations are likely to have been taught previously at Key Stage 3, this scheme assumes no prior knowledge of text-based programming. This is ideal for those students who might have missed out on this foundation knowledge, or never quite understood programming. Even for the more advanced programmers, it is helpful revision and an opportunity to embed good habits such as using subprograms with every program.
After teaching programming for 25 years, we have noticed patterns in student progress. There seem to be points at which students begin to find new concepts in programming difficult. This scheme is structured to identify those points enabling more practice before continuing.
The basic programming constructs of sequence, selection and iteration are introduced together with holding data in memory using constants and variables.
At this point student can write many simple programs, but progressing beyond this can be difficult for some students. It is important that knowledge is mastered now before continuing to more advanced programming concepts.
Random numbers allow students to make more interesting programs, and it is logical to introduce other number operations at the same time: modulo and integer division, required by GCSE specifications. Count-controlled iterations provide a mechanism to iterate over the elements of one-dimension arrays and lists as a better alternative to many variables, giving the loop a specific purpose without confusing it with the need for condition-controlled iterations. The need for passing parameters between subprograms and using local and global variables arises as programs become more sophisticated.
At this point students can write many complex programs including the sorting and searching algorithms required by GCSE specifications.
Students can now understand that strings are just arrays of characters and can be manipulated as such. Files provide a way of permanently storing data, but they also come with the potential for unexpected run-time errors. Two-dimension arrays and lists provide for storing tabular data which can be read from CSV files. The foundation is laid for more advanced structures to be introduced at A level.
At this point students can begin to appreciate the more advanced programming concepts having embedded the essential knowledge in the previous levels.
The assessment points at the end of each set of three levels provides an opportunity to check if the knowledge is embedded and transferable to new, seemingly unrelated problems. The assessments are deliberately difficult, but themselves progress in difficulty through the success criteria. They don’t require any additional knowledge beyond what has been learned to that level.
By splitting condition and counter controlled iterations across levels, students can appreciate the difference and purpose of each. Teaching these together often confuses students and as a result they default to using condition-controlled iterations for all loops. The sequencing and progression in this scheme aim to prevent this from happening.
By splitting one-dimension and two-dimension arrays and lists, the cognitive load is reduced. Using and manipulating more than one dimension is hard for many students to comprehend as abstraction becomes necessary. Students often confuse an index with an element. Working with one-dimension arrays and lists and becoming confident in those with spaced learning before introducing two-dimension arrays and lists results in a more successful learning journey for students.
Learning and practice programs follow one or more steps of our adaptation of PRIMM, called TIME. The acronym just makes more sense!
Students are introduced to new concepts through pre-written programs, explained with a “live coding” video. They can try running the programs to see what they do, beginning to appreciate how the commands result in the output.
Examining pre-written code and asking questions about it build good program comprehension and an understanding of syntax.
Making a modification to an existing program builds confidence rather than the daunting prospect of starting from a blank sheet. Syntax guides, flowcharts and Parsons problems are available to support students to be successful.
Self-evaluation by checking that a program meets the success criteria from developing and running post-development tests. Reflecting on the use of good programming practices and the approaches taken with oral feedback from the teacher.