Programming

  1. |
  2. Our Pedagogy
  3. |
  4. Programming

A better approach to teaching and learning programming

Craig'n'Dave believe that programming lessons and resources should:

  • Enable all learners to make progress from different starting points.
  • Allow students to work at their own pace with appropriate challenge, and in doing so find engagement.
  • Allow learning to continue away from the classroom as much as possible, and allow students who are absent to easily continue or catch up.
  • Allow students to predict, run, investigate, modify and make programs.
  • Not hold students back.
  • Provide appropriate scaffolding.
  • Allow students to take some ownership of the learning journey so it isn’t simply, “learning on rails”.
  • Allow students to tackle small real-world problems that are similar to those they may find in exams.
  • Allow the high ability students to expand beyond the scheme of learning with study relevant to the specification or future ambitions.
  • Give you time as a teacher to interact with individual students as much as possible and not be tethered to the front of the classroom.

We believe this because if you attempt to teach programming to all students simultaneously from the front of the class you will discover that some students don't understand or aren't following, some students need more individual guidance and some students are bored because they already know what you are trying to teach them.

Based on research and experience

The Craig’n’Dave approach to teaching programming is revolutionary. Not because it is a new pedagogy, but because it is the first set of resources to truly unify all the proven pedagogies for teaching programming effectively. Wrapped into one scheme of learning for teaching and learning the fundamentals of programming in Python and C#, our resources are deeply rooted in the methodologies proposed by:


  • Barak Rosenshine (10 principles of effective teaching)
  • Sue Sentence (PRIMM: Predict, Run, Investigate, Modify and Make programs)
  • Carsten Schulte (Program comprehension)
  • Dale Parson (Card sorting programs)
  • Alan O’Donohoe (Stepped challenges and paired programming)
  • Richard Pawson (Functions first)
  • William Lau (Reducing cognitive load)

Craig'n'Dave call their unified pedagogy for teaching programming T.I.M.E. After all, mastering programming takes time!

Learning to program takes T.I.M.E.

Our students learn programming independently. Working through a set of ten objectives at their own pace means that no student is left behind and no student is waiting for others to catch up. There is no need for students to listen to their teacher talking about programming, the best learning happens by doing, not listening! Students self-select differentiated problems to tackle that allow them to consolidate their understanding or challenge themselves further. Each objective has four stages.

Try

Students look at a coded solution and predict what the output will be. Students type in the code to see if they are correct. This approach aims to simulate how self-taught programmers in the 1980s used code listings in magazines and programming manuals to learn to code. Not starting from a blank screen is less daunting for students, provides models and guides student practice.

Investigate

Students learn how the sample programs work, understanding the new commands introduced. A set of small tasks instruct students to modify the sample programs they have been given. At the end of the stage keywords and learning points are summarised as a handy reference. The syntax of related additional commands is also presented that were not needed in the sample programs but could be useful to students when writing their own programs. These also include all the commands listed in examination board specifications.


A set of progressive comprehension questions also provide students with an opportunity to consider what terms mean, what commands or blocks of code achieve, how they work and why they are used. A deeper knowledge of syntax and programming constructs allows students to adapt to new commands more easily. This is based on a simplified student-friendly version of the block model of program comprehension proposed by Carsten Schulte.

Make

Problems to solve independently are presented in a mixture of written English, flowcharts, pseudocode, Parsons problems and output focused. Problems increase in difficulty indicated by the number of points associated with each problem. Each objective includes three 1-point problems, three 2-point problems and three 3-point problems. There are so many problems to attempt that students will not have enough time to complete them all so they can take ownership of their learning and select which ones to solve for themsleves. There is a clear focus on consolidation, progress, stretch and challenge. Students are encouraged to use whitespace, indentation, sensible variable names, and subroutines from their very first program.

Evaluate

Objectives will frequently require students to create and use test tables to test their solutions to the problems. This encourages good practice and teaches the importance of robust code. Once students have finished an objective, teachers have oral feedback conversations reflecting on the problems attempted. Using our feedback framework to structure conversations on comprehension, maintainability, scalability, robustness and approach taken.

Registered in England and Wales: 10442992 | VAT: 290 9845 58 | 03330 164 059