LEARNING AND TEACHING — A PHILOSOPHY, A GUIDELINE, A DISCUSSION…

Computer Science, not taught widely before in both primary and secondary education in England, is a new compulsory subject from September 2014. Consequently, there is inevitably a lack of tuned-in pedagogical expertise in the subject. In this Course, we address established pedagogy in Computer Science, and contributions from other subjects including Mathematics, Science and Languages, in order to facilitate learning and teaching for teachers engaged in this new enterprise.
Our approach to pedagogy is expressed imperatively, both as a reminder to ourselves, and as an urgent, cordial invitation and challenge to teachers to join the debate. We are initiating and setting out this discussion specifically in the context of this Course, in order to illustrate practically our proposals.

GENERAL: THE REFLECTIVE PRACTITIONER IN COMPUTING

1. Develop Your Own Model of Learning and Teaching in Computing.

   Does your model include your rights as a person as well as your responsibilities? Do you explicitly reflect on you and your work. Does boundary figure in your model? Do you achieve a working balance in your life? Do you feel creative in your work? Having a model of learning and teaching is an example of abstraction.
   What sort of learner are you? What sort of a teacher are you? How do you do/be as a teacher of computing? Instructionism or Constructionism? Have you heard of Seymour Papert?https://tltl.stanford.edu/content/you-cannot-think-about-thinking-without-thinking-about-what-seymour-papert-would-think
   http://dl.acm.org/citation.cfm?id=1095592
   What other questions for yourself would you want to address here?

2. Expand. Take up relevant training: targeted CPD is available at the local CAS hub. Make contact with colleagues in your local CAS hub and use the extensive and targeted resource repository on the CAS website: computingatschool.org.uk, and for this Course, the website www.ispython.com and the VLE at UCL moodle.ucl.ac.uk
3. Collaborate. Network and work in partnership with colleagues. And on the ground with teachers and pupils in your classes, as guide, co-explorer and mistake maker.
4. Improve your Computer Science Pedagogy. Take part with a group of colleagues to share appraisal and feedback on your individual Teaching skills.
5. Teach: Programming is More. In a nutshell it involves Computer Science pedagogy — a model of learning and teaching, 5 elements of computational thinking, 5 control structures, 5 data structures, at least 3 paradigms of programming,… to change the world.

A MODEL OF LEARNING AND TEACHING

6. Adopt a Constructionist Approach derived from Piaget’s Constructivism, applied to learning programming and concepts in Computer Science, a philosophy of learning and teaching developed by Seymour Papert and promulgated in the many years that the programming language Logo has been in existence. Computing is extraordinarily rich in the ways of learning and teaching. It can include, and lends itself to, creativity, experimenting, scientific enquiry, learning by doing, research, deduction, elementary mathematics, trial and error…
7. Model the Roles You Take On. As a Master teacher, be a model as a teacher for your class of teachers. Be a model for thinking like a Computer Scientist; be a model programmer…
8. Use a Variety of Inputs to Reinforce your Delivery. Usual classroom and laboratory fare including Google and other relevant online resources, plus targeted unplugged lessons; materials for learning produced by (your) programming both unplugged and at the screen, (Worksheet 2, power.py…). Download from ispython.com.
9. Think like a Computer Scientist. Underpin the learning with your model of Computational Thinking (ADAGE) and make the thinking explicit wherever you can – the content and the process are important to understanding. In short: “making and making sense: hands on and minds in”.
   • Algorithmic Thinking – thinking through the strategy and steps required to solve a problem
   • Decomposition – breaking a problem down into smaller components
   • Abstraction – reducing complexity by using or creating tools
   • Generalization — adapting solutions so that they can be used to solve a wider range of problems
   • Evaluation – assessing whether a program or technique works correctly or efficiently
     

     Exciting Cross-Curricula Topic

     Choose an Exciting Cross-Curricula Topic to explore when teaching programming — programming is not an end in itself; for most people it is always about something. We choose Geometric Regular Shapes and Patterns as our topic to program. Scratch 2.0, Logo, Python 3 and UPL (for unplugged work) as our languages — all have the immediate reward of pet/robot/sprite/turtle graphical/motion output with simple instructions(functions) to manoeuvre the pet/robot/sprite/turtle. Scratch came of age as a fully-fledged programming language with the arrival of the explicitly defined function facility (custom block), which arrived in Scratch version 2.0 in April 2013.

10. Design a Simple Pathway Course, which pursues the topic, makes explicit reference to computational thinking as it arises, introduces the 5 control structures of programming and gives plenty of practice in algorithmic thinking and programming unplugged and at the screen. In this Course, we also address the transition process from graphical to text-based programming.
11. Emphasize the 5 Control Structures of Programming. In the narrative of this introductory Course, the relevance and importance of the fundamental control structures: Sequence, Repetition, Function, Selection, and Communication will arise naturally; and we set up a minimum set of ‘do-able’exercises (Activities up to 1*) to ensure a basic level of programming experience with these structures and further Activities (2* – 5*) to develop expertise.
12. Beef Up Your Pedagogy of the Topic. Put in some time on the pedagogy of the topic. Programming itself makes good use of aspects of pedagogy from elementary mathematics, science, languages (yes we are dealing with languages!) and literacy. Consult and observe colleagues in these disciplines. (It’s also evident that the delivery of these and other subjects can benefit from a knowledge of programming).
13. Understand the Technology. Whatever programming language we are learning to implement, whether from scratch(!), or as part of a transition process. It is important to understand the technology of the topic. We have chosen a pet/robot/sprite/turtle for the language to drive. It is the same technology in UPL, Scratch, Python and Logo. A pet/robot/sprite/turtle/ is defined by 2 characteristics:
    • its position on the screen, or for a pet/robot, where it is standing
    • the direction in which it faces. (The red arrowhead defines the starting position and direction of the turtle in Figure 1.)
    

    Figure 1a. ‘Unplugged’. The 2-instruction program in UPL (Unplugged Programming Language), symbol-driven in up1.py and the equivalent drawing on the turtle screen.

    

    Figure 1b. The 2-instruction program in Scratch, Python and Logo and the resulting drawing on the turtle screen.

    The instructions in the languages are identical in some cases and easy to map to the equivalent instructions in others.

14. Keep it simple. Restrict the focus. We are teaching and learning about algorithms and the fundamentals of programming. Avoid too much detail at the beginning. We choose just two or three instructions in the language: move 100 units in the direction in which it is facing; and turn left/right through 90 degrees. A two instruction program is our starting point, which we have illustrated in the different languages, see Figure 1. For example, as we proceed through the Course, of the 100+ Scratch instructions available, we focus solely on a small subset, which will enable us to fully complete the Course.
15. Use Questioning – Unplugged Scientific Enquiry-Based learning – both oral and written to explore background understanding of the topic, the programming process, and to break down problems into simple components (decomposition). See Worksheet 2.
16. Set About Cracking the Code. Utilise the precept: we read before we write. Interpret simple programs unplugged in UPL. Practice recognizing patterns and symmetry in the ‘unplugged’ code and in code snippets in Scratch, Python and Logo. Examine and make sense of examples of programs in the languages we are learning, from simple instruction sequence to programs involving examples of the control structures repetition and functions. Compare examples of control structures and programs between Scratch and Python/Logo.
17. Encourage and set up experimentation opportunities and Use Different Approaches — algorithmic thinking to construct and evaluate different programs and solutions. Encourage creativity, trial and error, looking for symmetry, patterns, induction, deduction, enquiry-based learning. Try different approaches to a problem. There is rarely just one way of doing something.
18. Unplug Yourself and Diversify the Learning. Come to the screen prepared. We can learn enough of the basics of programming in an unplugged setting to make learning to program at the computer a more successful and rewarding experience. We can also introduce requisite subject/topic knowledge and skills before we approach the screen. How do we do this:
    • Using the UPL instructions in pairs work, as physical ‘walking the pet or robot’ activities, or on paper drawing the path of a pet or robot, in a more relaxed play setting away from the computer, thereby imitating the action of sprite/turtle on screen, before attempting on-screen programming (Worksheet 1)
    • Using an ‘action geometry’ unplugged approach to explore the exciting cross-curricular topic, emphasising pattern recognition and symmetry in algorithms, programming and geometric shapes and patterns. (Worksheet 2)
    • Finding first program solutions in UPL before attempting to move to programming in the Scratch 2.0 environment. This can include sequence, repetition and the use of functions. UPL can also form a precursor to Logo and Python if you are not using Scratch.
    • (If you are using Scratch before Python) Harnessing the benefits of Scratch 2.0 and its freedom from syntax and formatting errors in developing sequential solutions to problems along a simple pathway through the topic. And its relatively straightforward custom block facility for functions.
    • Using the structural similarity of programs in Scratch to text-based languages to map working programs in Scratch to Logo/Python. This enables pupils, after what is essentially a copying/mapping process, to concentrate solely on correcting any syntax and formatting errors that arise in the Logo/Python program.
19. Spread the Word — You (everyone) goes on making mistakes in programming.
    • Make it clear that making mistakes is part and parcel of the learning process, particularly, in programming. And that you will come to recognise your mistakes (that forgotten colon, or closing bracket!) and come to know the meanings of those sometimes indecipherable error messages from IDLE. (That the real error is 2 lines back from where IDLE is flagging!)
    • That tenacity and resilience in correcting mistakes in programming as you go, is practising an aspect of a rewarding life skill
    • Willingness to ask for help from peers and others is a worthwhile addition to, but not a substitute for, trying to work it out for yourself.
20. Develop a Debugging Resource for dealing with the common syntax and formatting errors of Python, and interpreting error messages generated by the IDLE Python environment.
21. Make an Art of Testing Programs (evaluate). Just the introduction of well-judged positioning of print statements when trying to find out what a piece of code is doing is so revealing. Keeping programs modular with the use of functions helps to crack the code in a workable scope…
22. Look at Ways to Extend and Simplify Solutions (generalize). We can do this by experimenting with changing parameters in instructions, which happen to be functions, and by introducing user-defined functions with parameters, where appropriate, to simplify code by hiding complexity (abstraction).
23. What to Leave till Later. Research and experience in teaching programming suggest that pupils struggle with certain aspects of the learning, which may impede their progress. These aspects include: text-based language environments and syntax, use of variables, nested structures, different forms of input and output, complex data structures, concurrency, initialization, and so on. Delaying the introduction of these aspects enables pupils to progress readily to a point where they feel they have secured a firm enough base in the practice of programming, and to be confident to move forward with their skills. We have designed an introductory Course which takes account of these findings.
24. Find a variety of approaches to difficult aspects of learning. Allow for pupil experimentation, discovery, use graded problems for pupils to solve to introduce the subject: hook in with enquiry-based sessions, illustrate with action software… Come back to a difficult subject in a variety of ways to reinforce learning. For examples, see how functions, external turning angle for a polygon, and nested repeat loops are introduced on the course
25. Show How Useful Programming is. Use the newly acquired Skill of Programming in Python. Develop and introduce more advanced constructs in Python, e.g. colouring-in, with graded problems to solve, to further the exploration of the topic you have undertaken with which to learn programming.