1. Develop an ongoing pedagogy in computing (ispython.com/pedagogy) guided by: a project-based problem-solving approach, current research findings, classroom experience, existing expertise in other disciplines. And  we look to take part in further action-research in the classroom.
2. Select a cross-curricula problem domain, interesting and responsive, fun for pupils to explore, and fertile in problems to solve
3. Examples.  Choose a do-able  project to undertake. Use graded and related example problems (decomposition) first for practice, and so build confidence before taking on the project.
4. Choose a basic appropriate programming toolbox in which to design and create user-tools for problem solving in this domain.
5. Implement the simple, but general, paradigm for problem solving in computing:                                                                  program(toolbox + user-created tools) = solutions
6. Harness computational thinking in problem-solving to achieve a human solution in pursuit of a program solution.

1.  ISPY (red arrow) – push-button, instant response, scaffolded programming for beginners
2. Scratch 2.0 (sprite)
3. Python 3 (turtle)

• Inhabiting  a drawing  environment,  in which the project and related problems have an ongoing graphical response with which to gauge progress. (The response is instant when using ISPY and Push-Python.)
• Selecting a project and adopting a problem-solving approach to learning computational thinking and programming
• Investigating human solutions with pencil and paper
• Unplugged programming:  with the ‘human’ robot ‘Walking the Talk’  programming solutions
• Practising with simpler but  related problems
• Enquiry-led learning
• Reading  code before you write code (on ISPY)
• Opportunities for experimenting, using and creating tools, and learning by doing
• Guidance in graded problems to promote computational thinking in programming
• Looking at different solutions (generalising and evaluating)
• Transferring our drawing/walking solutions, and our robot solutions,  for further development to the screen with

• that the developing programming produces an immediate response, whether that is:
  • Drawing on paper
  • “Walking the talk” — motion with a ‘human’ robot
  • Flying red-arrow using ISPY on screen. See Figure 3 and Session 4).
• There is a direct correlation between the three positional movements: forward, left turn and right turn of the unplugged human robot, the activities listed above, and the motions of the Scratch sprite and the Python turtle, all of which inform the transition from KS2 to KS3, unplugged to block-based to text-based programming.
• Consequently, you can move to ISPY, Scratch 2.0, Python 3 now, or at any point in this Course. We think there is much to be gained by first focussing on and gaining competence in the computational thinking in human problem solving by devising an ‘unplugged’ program of drawing/walking the robot, and/or an ‘unplugged’ program to move the red arrow in ISPY by pushing buttons. The pupils’ ‘unplugged’ programs, which will employ the basic ‘motion’ instructions of a robot/sprite/turtle and the programming concepts of sequence, repetition and functions are straightforwardly mapped into Scratch 2.0 and Python 3. The additional challenge of the learning in detail required to familiarise pupils with a block-based or text-based programming environment can then be undertaken to implement the ‘unplugged’ program solutions in Scratch/Python. An introduction to Scratch 2.0 geared to this course can be downloaded from repository-2.
• Symmetry and pattern in drawings can be used in computational thinking to link the corresponding symmetry and pattern in the code and vice-versa, via the programming control structures of sequence, repetition and functions.
• Using the instructions: fd1, lt, rt what is the code for this staircase?
  [Answer:
  fd1 lt fd1 rt
fd1 lt fd1 rt
fd1 lt fd1 rt …………… UPL(1)
• but see Session 3… “Introducing Repetition…”  for more concrete discussion]

• Show the Aqado board and the reduced model in Figure .
• Give out paper and pencil. Ask each person to draw just the 3×3 grid model.
• Ask them to describe how they did it — their algorithm for a human solution.  (Algorithmic Thinking)
• Draw their attention to the symmetry in the 3×3 grid and the components that make up the grid. Ask them to draw the 3×3 grid again ‘systematically’, to bear in mind that they might want to draw a 4×4 or a 10×10 grid later on…(Generalisation)
• In small groups, ask them to discuss and come up with 3 or 4 really different ways to draw the 3×3 grid. There are at least a dozen different ways…
• If necessary, give them a hint: What do you see in the model as potential building blocks/templates to repeat in order to draw the model ‘systematically’. [ lines, squares and rectangles…]
• Ask them to choose one solution they can use to build a program which seems easiest — perhaps easiest to generalise. (Evaluation)

• Describe ‘Walking the Talk’ with the 3 instructions, in UPL (unplugged programming language): forward, left turn, and right turn to drive the robot. These instructions are common to Scratch, Python, (and other languages which implement the sprite/turtle). Together with the universal programming control structures of sequence, repetition and functions. The toolbox can be expanded (later) by introducing user-defined functions/instructions representing building blocks e.g. squares, lines, or rectangles.
• Find out if everybody knows what characterises a robot/sprite/turtle/ in the plane when we want it to move? (Enquiry-led learning). [Answer: position, direction]
• Ask everybody (who agrees to) to stand up and be a robot.
• Describe how at the start, a robot faces to the right as the handler views them, and chooses enough space in front and to their left to allow at least one pace forward or to the left. (If you think of the floor as a page, on which they leave a trail — a drawing, each robot is standing at the bottom of the page and the top of the page is to their left). See Figure 3.

• Get all the robots moving.See ‘Walking the talk’ and ISPY in action. Give the following commands verbally. (To illustrate the repetition with your voice — pause after each line):
  forward one, left turn
forward one, left turn
forward one, left turn
forward one, …………………………UPL(2)
• Ask them to describe what happened, and what they have drawn.
• What would be the effect of adding another instruction: left turn in the last line of the example?

Figure 7 (a),(b)Two programs for a square — one symmetric (b)– a returned program.

The same program in the UPL short code, (and on the push buttons in ISPY) would be:

We are looking for repetition and symmetry together in the shape drawn, and in the code. The complete code symmetry is finally achieved by adding the lt command on the final line in program UPL(2). An example of a  return  program. (One where the robot returns to the starting position and starting direction).
Note the symmetrical code for the square consisting of 4 repeated lines of code for a return program:

We shall pick up on symmetry and repetition of code in programming again in Session 3.

• Get the participants to inhabit the robot/handler relationship by working in pairs to understand and practise the three moves. For example, by drawing a capital letter from an easy-to-draw  set: ‘L’, ‘I’, ‘F’, ‘T’, ‘E’, ‘P’ or other shapes: rectangles, squares, ‘+’, ‘9’…
  The code for capital L, with the robot starting from bottom left and facing right, could be:
  forward one, left turn, left turn
forward one, right turn, forward two……..UPL(6)
  The return program in Figure (b) is achieved by adding the instructions
  left turn, left turn, forward two, left turn
  to the end of the previous code (A return program is one which finishes with the robot, sprite or turtle finishing at the starting point and pointing in the starting direction)
• Draw a rectangle using a return program. Thus illustrating how the symmetry of the drawing is reflected in the code

Figure 9. A 3×1 rectangle

[Ans: The code for a 3×1 rectangle could be:
forward three, left turn, forward one, left turn
forward three, left turn, forward one, left turn……..UPL(7)
or in the short code version:

When there is a repeat symmetry in the code it is useful to pick this out by lining the code up with repeats on consecutive lines, see UPL (1),(2),(3),(5),(6),(7),(8) — in preparation for using the repetition structure in the programming language.The return program often helps to complete symmetry in the code, but it is also an important concept when later we want to create patterns.

Introducing Repetition and Functions with the ‘Human’ Robot

Sequence, Repetition and Functions in Unplugged Programming

Programming languages contain repeat structures. So we ask our intelligent robots to recognise their ‘wired in’ repeat ability.

Give the command (with intonation to insert the brackets!):

repeat 4[fd1 lt]………………………………UPL(9)

and watch them obey.

Then call upon their ‘wired in’ understanding of functions and name the code square1 or sq1 (for short when we go to the screen), a function with a parameter ‘pace’, which could be 2, 3 … paces along a side of a grid, in a similar vein to the function forward1, 2, 3… paces. (In unplugged programming, we define a user function by the code we name but, helpfully, not yet with a formal syntax definition for the function or its parameter). Again it is essential to note that when we issue a command (instruction/user function) that it gets the robot to act from its present location and direction.

{** this more formal notation we introduce in later sessions. We can define and use our user functions in unplugged programming without it.

More formally, we use ‘–>’ as our symbol for ‘defining’ a function with a parameter p by writing:

squarep or sqp –> repeat 4[fdp lt]………………………………UPL(10)

Where p can take values (arguments) 1, 2, 3… **}

Give the command:  square2. (See Figure 5 below for same command in ISPY). Note that every command that we give to the human robot, is available at the screen with ISPY.(Figure 5.)

(For robot practice, divide into pairs, handler and robot, and the handler uses instructions to the robot partner to draw some capital letters: e.g. I, L, F, E, T, P or combinations of square and write down the corresponding return programs. The handler can, in each case,

1. build the code for the letter from the three instructions,
2. by taking note of symmetry in the drawing, use the repeat control structure in the program,
3. by identifying building blocks for the drawing, include user-defined functions in the program.

Examples: For Figure 4(e) L the code might be:

            fd1 lt lt fd1 rt fd2………………………UPL(11)

or as a return program

           fd1 lt lt fd1 rt fd2   lt lt fd2 lt……………………………UPL(12)

and for Figure 4(f) F the code might be

             lt repeat 2[fd1 rt fd1 lt lt fd1 rt]……..………………UPL(13)

or as a return program

lt repeat 2[fd1 rt fd1 lt lt fd1 rt] lt lt fd1 lt fd2 lt………UPL(14)

and for Figure 4(g) P the code might be (note the use of user-function sq1)

           lt fd1 rt sq1………………………………………………………………………………………UPL(15)

or as a return program

           lt fd1 rt sq1   rt fd1 lt.……………………………………………………UPL(16)

The above code introduces and illustrates our programming paradigm

program(toolbox + user-created  tools) = solutions

by making use of:

• the toolbox instructions fd, lt and rt
• repeat programming control structure
• functions: user-defined function like sq (because the instruction sq or square is not already defined as an instruction in the repertoire of the sprite or turtle, and it is useful to us in our proposed solutions)

(E.g each capital letter could then be named as a user-defined function).

Try the remainder of the examples in Figure 4, identifying symmetry and building blocks in the drawings to use repeat and user-defined functions in the programs.

We can define two more building blocks as user-defined functions: a (return) line and a (return) rectangle to help us with alternative solutions for the 3×3 grid:

     fetchp (fep) –> fdp lt lt fdp lt lt………………………………………UPL(17)

       rectanglep (rep) –> repeat 2 [fdp lt fd1 lt]………………UPL(18)

(a rectangle is here defined to have a variable length parameter: p paces, and a fixed breadth of 1 pace).

For  letter E, the code might be

      fe1 repeat 2[lt fd1 rt fe1]……………………………………………………………UPL(19)

These are more examples of user-defined functions — the building blocks identified in the discussed solutions. This illustrates the problem solving paradigm: Choose your toolbox for the problem, and create more tools (functions) to represent the physical building blocks for your drawings as you need them.

Results: Teacher devised solutions of 3×3 model written after ’Walking the talk’:

Solution 5 uses some duplication in that it redraws lines already drawn, but the program is short and elegant. Does it generalise?

Solution 6 defines a function for a row of squares rowsq using an existing user-function sq. Clever and works for 3×3. Not easily generalizable. How would you adapt rowsq to write a program that was easier to generalise? (Return program?) How many of 1-6 are return programs? (Plenty more solutions! Lots of discussion, but all teachers agreed they could build the programs in UPL, Scratch or Python.)

Graded Challenges: Why would you draw a grid? Board Games challenges in UPL (ISPY) include: 3×3 Noughts and Crosses; 4×4, 5×5, 6×6 Boggle (a spelling game on the grid); 6×6 Conway’s Game of Life; 7×7 Othello;  8×8 Chess and Draughts; 9×9 Sudoku; 10×10 Snakes and Ladders; 11×5 Aqado; 13×13 crosswords. Other contenders: Ludo, Monopoly, Scrabble, Go, Connect 4.  Project 2 Pixels and Colour backgrounds, National flags, Bar scarves, Pixel pictures …

Further Challenges to come: move on to challenges in the open 2-D plane: polygons, stars, circles, curves, spirals, patterns, linear transformations:  translation, rotation, reflection; action geometry, transitional geometry. Solar system and planetary motion. Move on to graded missions in unplugged programming in ISPY and Push-Python (when live!):

ispython.com/ispy

All these problems are programming tasks and could be solved in Scratch 2, or Python 3, but ISPY has a version with an integrated graded problem set, and in all versions is incrementally interactive with no syntax errors, and no ‘save and run’ procedure and a delete button for semantic or logical errors, ideal as a transition phase and for learning Python 3. See Figure 5. If you want to carry on with problem solving on the grids without tackling a programming environment using the basic toolbox with repeat and user defined functions in a push-button environment then download ISPY1. Move on to ISPY2 when you want to introduce defining and using user functions and colour.

Otherwise you can proceed with the sprite of Scratch 2.0 or the turtle in Python 3. To help bridge that transition, we include at the end of this section Scratch 2.0  and Python 3 solutions for solution 4 above.

to be continued…

Session 4: Moving to the Screen with ISPY

to be continued…(we intend an improved beta version of the software for ISPY to be available for download for free day courses at UCL for teachers for Summer School 2017)

Figure . ISPY — Toolbox1
Picking up the symmetry in the rectangle 3×1 using a repeat instruction

Let’s Go — Practical Sessions for Teachers — Project 2: “Reach for the Stars” Regular polygons and Stars with ISPY

to be continued…