Kids at home? Free computing-themed activity newsletter from @cs4fn ^JB #HomeLearning #ComputingAtHome

Over the last 14 years CS4FN (Computer Science For Fun) has been creating and sharing with schools our FREE inspiring computing resources for use in the classroom. Our sister project Teaching London Computing (this website) also supports teachers directly with continuing professional development.

During lockdown we’re gradually converting some of our school resources into a format that doesn’t need a printer – so that they can be done on a computer (or tablet) or done with pen and paper – or even with a pack of cards. (We do have printable stuff too but not everyone has a printer at home).

We’re creating a new short email newsletter for families so that we can share our free resources with them. We’re already in touch with lots of teachers (our printed magazines alone go to 2,300 subscribing UK schools) but not so much with other parents and carers… yet. Can you help us to reach them?* Thanks! (Here’s a Tweet you could share too)

This is the link for the sign-up form and it’s embedded below. If you want to read the newsletters but don’t want to sign up we’ll add them here so please bookmark this page.

*But please don’t sign up friends without getting their permission first – thank you!

To start you off here are some Home Learning activities for Primary and Secondary.


Teaching London Computing Newsletter #6 – January 2020

Welcome to our sixth Teaching London Computing newsletter (the previous newsletters live here) and you are welcome to forward this to colleagues – new readers can sign up using the orange form on this page.

Follow us on Twitter @cas_london_crc or @cs4fn.


1. Paul Curzon wins the Booth Education Award for CS4FN / TLC
QMUL’s Prof Paul Curzon has won the Booth Education Award 2020 for his “outstanding record in computer science and engineering education” thanks to his creative output through the CS4FN project (co-created with Prof Peter McOwan) and the resources on the Teaching London Computing website. You can read more about Paul’s contribution to computing education in the UK, in this CAS forum post from Simon Peyton Jones (you will need to create a free account to access, or you can read a copy on our blog).

Paul said of his award

It is a really nice and wonderful surprise to receive this award. I am only one of many people worldwide who have been contributing to the rebirth of Computer Science in schools, including many colleagues at Queen Mary and elsewhere, who have helped me in my work.

“I have always aimed to support teachers in making the subject fun as well as rigorous. What matters most is that we continue to inspire students about how exciting the subject of Computer Science can be. I hope I have contributed at least a little to that goal.

Courses, conferences and events

2. CAS London Conference – 29 February 2020
Our one-day CPD and networking event on Saturday 29th February 2020 is now sold out and we have opened the waiting list. If you’re no longer able to attend please let Jo [] know ASAP and she can release your ticket for others.

3. TechPathways courses – 11 March 2020 and onwards
QMUL are running four courses through TechPathways London which are free. The first is “Teaching networks KS3 – KS5” which is on 11 March 2020, then three others are coming up later in the year Games Development with Construct 3 at Ukie, 22nd May 2020 and Creating 3D Animations with 3Dami at King’s College London, 11th June 2020 and Teaching Geographical Information Systems (GIS) for Secondary Schools at London CLC, 7 July 2020.


4. NCCE / STEM Learning and Raspberry Pi courses
London-based courses information for January and February 2020 are listed on our blog post here but the full range of computing courses can be found at the STEM Learning website – search for London or use the region filter (in the panel on the right hand side, near the bottom) to bring up courses nearest to London. Online-only courses can also be found at, Raspberry Pi provide some of the courses,, a subset of which will also contribute to the CS Accelerator certificate. To search the course listings you will need to create a free account.

5. ICT for Education conference, 13 March 2020, Brighton – free places
ICT for Education is an independent producer of regional computing conferences for UK schools and they have a free conference on Friday 13 March 2020 for teachers. There’s a PDF of the conference invitation and a POSTER.



6. New Teaching London Computing resources
We have two new art and computing resources which draw their inspiration from Bridget Riley and Wassily Kandinsky. The resources will let you and your class use a computer program to generate op-art / abstract art and can also be used as a way to explore the differences between vector and bitmap images, and the importance of following a sequence in order.

7. Our puzzle books are now free
We’ve added the Puzzle Book to our available back issues and the updated (blue) form can be found on our sign-up page. There are other forms on that page – the first (orange) is for people to sign up to receive this newsletter, the second (purple) is for schoolteachers who want to receive copies of the next CS4FN magazine and the third (blue) to request back issues of available magazines and booklets etc.

All our previous CS4FN publications are freely downloadable as PDFs.

8. Careers advice support from Digital Schoolhouse
One Minute Mentor (OMM) is a new careers resource which aims to inspire pupils with the breadth of roles available in the creative digital sector through punchy, digestible videos hosted on Digital Schoolhouse’s YouTube channel.

This resource features a library of one-minute videos made by professionals within the sector “to educate aspiring pupils on careers pathways they might not have otherwise considered”. Teachers can use the One Minute Mentor library as a resource to inform students about the possible career paths in the video games and wider creative digital industries.



9. Take part in research
A PhD student at the University of Abertay, Dundee is investigating “the ways online automatic assessment assistants could help specifically students between the ages of 14 and 16 learning how to code in either Python or Java while completing a GCSE/IGCSE in Computer Science.” If you’d like to contribute (and if you’re a teacher from “state and independent schools that teach any of the OCR/AQA/WJEC/Edexcel/CIE (IGCSE) Computer Science specifications”), find out more here:

10. 20 things every computing teacher should try in 2020
Some suggestions to inspire you from Teach with ICT:


  • Learn a Tudor Algorithm to do hard times tables
  • See a simple (and useful) example of what algorithms are.
  • Understand why algebra is really useful – for proving algorithms ALWAYS work

Algorithms are magic. Even simple algorithms can sometimes look like witchcraft. My favourite is one of the ways the Tudors did multiplication. It is all down to Welsh Tudor polymath Robert Recorde. As well as being a mathematician, who wrote the first arithmetic text book, he was also the physician to two Tudor Monarchs: Edward VI and Mary. Not only that, but along the way he also invented the equal sign using it for the first time as a shorthand for the phrase “ is equalle to” when doing maths (he would have liked the C programming language!). He was particularly good at algorithms and his book contained a cunning way to make the times tables easier.

Learning times tables is a rite of passage of primary school students. Those up to 5 are not too difficult but the 6, 7, 8 and 9 times table are particularly hard to remember (though of course the 9 times table does have a cunning pattern that makes it easier). Robert Recorde had a solution. In his book he gave an algorithm that made those larger times tables easy. If you know your tables up to the 5 times table (the easy ones), then the rest become simple too. It is just a matter of knowing the algorithm and doing some simple subtractions combined with the multiplications you do know. That the algorithm works is barely believable though, it is so odd.

The Algorithm

Here is how it goes. Suppose you have two of those nasty higher numbers to multiply like 8×7.

  1. Draw 7 boxes labelled A, B, C, D, E, F and G. Write one of the numbers you want to multiply in box A and the other in box B.
    • eg if you want to calculate 8 x 7, put 8 in box A and 7 in box B.
  2. Subtract the number in box A from 10 and put the answer in box C.
    • 10-8 = 2, so put 2 in box C.
  3. Subtract the number in box B from 10 and put the answer in box D.
    • 10-7 = 3 , so put 3 in box D.
  4. Multiply the two numbers in box C and D together. Put the answer in box E.
    • 2 x 3 = 6 so we write 6 in box E
    • Because your original two numbers in A and B were above 5, the new ones you must multiply instead are both below 5 so its a nice easy multiplication.
  5. Now subtract the number in box C from Box B (ie the diagonal numbers) and multiply the answer by 10 (stick a 0 on the end) writing the answer in box F.
    • 7-2 = 5, so multiplying by 10 means you put 50 in box F.
  6. Construct the final answer in box G by adding the number in box F to the number in box E.
    • E holds 50 and F holds 6 so 50+6 = 56 is the answer to the original multiplication of 8×7.


Try the algorithm yourself on some more examples, like 6×9, 7×6 and 8×9. It seems a bizarre way to do multiplication – were the Tudors slightly bonkers? Well possibly, but Robert Recorde was just very clever. At a stroke his clever algorithm gives a way to do all those hard multiplications using only a few much simpler calculations.

Does it always work?

This little computational ‘spell’ seems like witchcraft! Surely it doesn’t really always work? Actually it does. The point of an algorithm is that it always guarantees you get the right answer. We can prove this one does with a bit of algebra.  Of course, as long as you trust Recorde, you don’t have to understand the proof for the algorithm to work for you. It is good to do the proof though (or at least have a rigorous argument) to be sure the algorithm really is fool proof.

The Proof

STEP 1: Let’s call the number in box A, a, the number in box B, b and so on. So we are trying to work out the answer to:

ab (thats just another way to write: a x b)

Now (see the diagram below) instead of doing the multiplication directly we work out


STEP 2: c = 10-a and

STEP 3: d = 10-b

We multiply these together e = c x d so to get the number in box E, replacing c and d by the terms they are equal to, we do

STEP 4:  e = (10-a)(10-b).

We also subtract 10-a from b, and multiply it by 10 to get the number in box F, so

STEP 5: f = 10(b-(10-a))

The final answer is then just g = e + f. This means the calculation we ultimately do is

STEP 6: g = 10(b-(10-a)) + (10-a)(10-b)

We need to show this value g is the same as a x b.  It looks a bit unlikely but let’s simplify it all.

g = 10(b-(10-a)) + (10-a)(10-b)

Expanding the brackets for the part that came from f gives:

= 10(b -10 + a) + (10-a)(10-b)

= 10b -100 + 10a + (10-a)(10-b)

Similarly, multiplying out the brackets from e’s part gives:

= 10b -100 + 10a + 100 -10a -10b + ab

Now having expanded everything, we simplify: the terms +100 and -100 cancel out

= 10b + 10a -10a -10b + ab

The +10b and -10b cancel out too.

= 10a -10a + ab

The +10a and -10a also cancel out, leaving just a single term.

= ab

So what this says is that following the algorithm leaves the answer of calculating a x b in box G which is just what we wanted.


Algorithms are just sequences of steps to follow that guarantee a result (whether you understand why it works or not). Here the result is to multiply two numbers doing only simpler calculations. Of course, computers don’t know what they are doing. They can only follow rules blindly. While perhaps not using exactly this algorithm, they do use lots of clever algorithms to allow them to do arithmetic quickly.

This bit of witchcraft also shows why algebra is such a useful thing. It is a great way of proving useful algorithms really do always work.

The Tudors may still mistakenly have believed in witchcraft, and may not have had computers, but their computational witchcraft was still a really useful thing.

This one is for Peter,  the only person I imagine ever to get spontaneous applause from a class of teenagers for algebra… and a wonderful computational magician. 

He also loved hiding Easter Eggs in our work.

Feedback matters

Here is the next in our series of tips about learning to learn (to program).

TIP 8 :  Immediate, Frequent Feedback Matters

Paul Curzon, Queen Mary University of London

The real key to deliberate practice, to putting in hours of practice that is as effective as possible, is to have immediate and frequent feedback. You need to find ways to be sure what you are doing is right (or wrong). You need to practice the right things and fix the causes when you get things wrong. Otherwise, with all that practice you could just  be getting better and better at doing it badly.

Building appropriate mental models of sub-skills is an important part of this as it can give a basis of being able to providing feedback yourself. The understanding you have can help you work out what you must have done wrong. When a musician plays the wrong note, if they can hear it sounds wrong, they have some feedback. They can work on that note until they consistently get it right.

Programming provides natural forms of feedback. If you write nonsense that isn’t a program at all, perhaps because a single bracket is missing, or because something was mis-spelled, then when you compile the program, the compiler will tell you about your mistakes. The feedback is immediate.  Compile your program frequently and you will get frequent feedback.

Similarly with a good test plan, and knowing what you are trying to implement you can get immediate feedback as to whether a program does the thing you intended or not in all situations.

This will only be helpful if you were not trying to do too much at once. If you spend days (or even hours) trying to write complex programs, before compiling and running then the feedback is not immediate. You only get feedback when you finally finish the whole thing. Therefore it is really, really important you practice by writing small programs, not large ones bigger than anything you’ve tried before.

When you do write larger programs, it is important that you build them a step at a time, adding to them a little at a time, then recompiling and testing them. This requires you to have understanding of the structure of programs as you need with each change to still have what you think is a valid program. This is a skill to gradually develop too.

So again we see that it is important to not try and make too large steps at once, to learn to program effectively.

It is because there are these natural feedback mechanisms in programming that many people teach themselves to program. As long as they are not put off by making mistakes and see them as learning opportunities they can use feedback from compiling and running programs to get better and better.

If you are a:

  • student
    • Practice writing small programs that introduce single new things at a time.
    • Write programs a little at a time, recompiling, running and testing frequently.
    • Don’t be frustrated by compiler messages, see them as feedback to help you improve.
    • Test programs thoroughly, not just once and then assume it works
  • teacher:
    • Set programming exercises that are small
    • For large programs encourage iterative development.
    • Provide exercises with test plans, teaching debugging skills.
    • Provide other mechanisms for immediate feedback if you can, eg marking programs on the spot as a student completes them, not having them handed in with feedback days or weeks later.

More on Learning to Learn (to program)

IoC logo on white