Introduction

• My name is Alisdair Tullo and I work in the school of Philosophy, Psychology and Language Sciences

• I hope to convince you that immediate visual feedback (or perceptual equivalent) is important in teaching beginners

• I realise that “immediate” and “visual” are two seperate things but I think they’re useful for similar reasons

• I’ll bring in other important stuff along the way

• I will undoubtedly talk about some unimportant things too

• Unflinching honesty about the drawbacks too

Everyone starts off boring (or I did at least!)

• First question anyone every asks is what do you use / recommend, so here we go ….

• The Old Days when I started, learning C and having to deal with compiler stuff before you even got any feedback (though even 1st year Computer Science in 1999 had a “washing machine problem” with visual feedback)

• I wrote a boring programming course: https://github.com/alisdt/python-intro

• How to add numbers, write comments, …. BORING

Notebooks are great

• Despite this I learned the value of notebooks for the very start of learning programming. It reinforces to the beginner that code corresponds to actions and gives them immediate feedback
  • need to deal with the “write a program” speed bump at some point
• Jupyer interactive prompt (https://jupyter.org/), even better as code can be grouped into cells, inline plots / images, other stuff
  • e.g. Conway’s Game of Life example https://github.com/alisdt/python-intermediate/blob/main/04LifeWithSolutions.ipynb
  • can run into execution order problems
  • but helps immensely with the “fail many times” problem
  • “Computer programming involves lots of failure‒often you have to fail several times to succeed once, editing the code until it works! This is ok and happens to everyone, even very experienced programmers. Most of the time there will be an error message, which will give you a clue to the solution for the problem.”
  • some learners perceive error messages as failure
  • on some programming environments (e.g. in a shell or prompt), you will see a log of these “failures” scrolling up the screen
  • in Jupyter you edit the code and rerun, and the error message is replaced with the correct output
  • this is visual feedback!
  • there are other toy environments with green lights that light up, in-browser progressive examples etc.
  • I prefer Jupyter because students can use it for real work, and install it on their own computer

Turtles are even better

• Errors disappearing is visual feedback, but I bet what you thought I meant is drawing pictures (I did)

• Turtles based on OpenTechSchool course, Thonny with JupyterHub fallback. https://softdev.ppls.ed.ac.uk/turtles/
  • Turtle graphics is directing a cursor (‘turtle’) around the screen, at least at first to draw shapes
  • This is not a new concept, original turtle was a 1940s robot that crawled around drawing on a piece of paper
  • You can “be the turtle” thinking about what it’s going to do, and read through the code
• Have also worked with Processing which is good for this too (particularly for playing around)
  • Processing is a self-contained environment in Java, Python or JavaScript where the user fills in a setup function (one time actions at the start) and an draw function (run every screen refresh). See e.g. https://p5js.org/

• also do HTML/CSS/JS for online expts. which is application focussed and more naturally visual / interactive! https://softdev.ppls.ed.ac.uk/online_experiments/

Why this approach?

• Series of assertions with no evidence other than my own experience, brace yourself

• Immediate feedback is motivating (or, lack of immediate feedback is depressing)
  • Though still has the “repeated failure” problem, https://softdev.ppls.ed.ac.uk/turtles/getting_started.html#computer-programming-and-failure
  • Another way of putting it: “how soon can I reassure the student that this is something that they can do?”

• Immediate feedback improves the student’s mental model of what the computer is doing

• Visual feedback in particular is just inherently more interesting than just fiddling with text and numbers

Some choices in teaching

• biggest problem in teaching beginners is getting stuck / frustration / “I can’t do this”

• biggest problem in writing a course to teach beginners is what to teach first

• when and what do I teach about low-level computing?
  • e.g. binary might explain 64/128/256GB phone sizes, but not that useful to beginners
• when and what do I teach about types?
  • e.g. I teach in Python, no explicit types to start with but becomes apparent soon (3 + “apple” -> error)

• when and what do I teach about flow and control?

• with visual feedback, pick a goal (something to draw) and that will lead through concepts

Visual and immediate isn’t everything

• people who come with a specific use for programming may not care – “why am I drawing a square”
  • or to put it another way, they want to get to their chosen goal quicker!

• “what to teach first” isn’t everything

• biggest factor in retention in my classes is the amount of sunlight / windows in the room!

• Students have to feel like they are being supported to learn (have enough tutors, teach in person if you can)