Answers not on the Screen

 
2. The answers not on the screen
Hill, G., Turner, S. J. and Childs, K. (2017) 

Abstract: Reflection from two areas on the issues of getting students in Higher Education (HE) to become better problem-solvers earlier. Asks some questions about should HE increase the use of unplugged activities? If so, is there any evidence that it will help? What lessons can HE learn from what is happening in Primary Schools? What can schools learn from what is and has happened in HE teaching of programming and problem-solving?

To find out more click here.

References

1. Hill, G. and Turner, S. J. : Problems first, second and third. International Journal of Quality Assurance in Engineering and Technology Education (IJQAETE). 3(3), pp. 88-109. 2155-496X. (2014) 2. Hill, G. and Turner, S. J.: Problems first. In: Hussey, M., Wu, B. and Xiaofei, X. (eds.) Software Industry-Oriented Education Practices and Curriculum Development: Experiences and Lessons. Hershey, Pa.: IGI Global. pp. 110-126. (2011) 3. Turner, S. J. and Hill, G: Robotics within the teaching of problem-solving. ITALICS. 7(1), pp. 108-119. 1473-7507 (2008) 4. Turner, S. J. and Hill, G : The inclusion of robots within the teaching of problem solving - preliminary results. In: Steede, H. (ed.) 7th Annual Conference of the Subject Centre for Information and Computer Sciences. Dublin: Higher Education Academy Subject Network for Information and Computer Sciences. 0955200539. pp. 241-242.(2006) 5. Bell, T., Alexander, J., Freeman, I. and Grimley, M.: Computer science unplugged: School students doing real computing without computers. The New Zealand Journal of Applied Computing and Information Technology, 13(1), pp.20-29. (2009) 6. Department for Education Statutory guidance 7. CAS Barefoot: Barefoot[online] http://barefootcas.org.uk/ [Accessed: February 2017] (NA) 8. Bell, T., Witten, I.H., Fellows, M., Adams, R. and McKenzie, J:. Computer Science Unplugged: An enrichment and extension programme for primary-aged children. (2005) 9. Turner, S. J. and Childs, K: Artists. In: Caldwell, H. and Smith, N. (eds.) Teaching Computing Unplugged in Primary Schools: Exploring Primary Computing Through Practical Activities Away from the Computer. London: Learning Matters. pp. 51-72.(2016) 10. Papert, S: Mindstorms: Children, computers and powerful ideas. 2nd edn. Hemel Hempstead: Harvester Wheatsheaf, ISBN 0-465-04629-0. (1993) 11. JICC5: Java & the Internet in the Computing Curriculum, Higher Education Academy (HEA) – Information and Computer Sciences (ICS) Conference, South Bank University, London, 22nd Jan, [online] Available from: http://www.ics.heacademy.ac.uk/events/displayevent.php?id=127 [Accessed: February 2015]. (2001) 12. IEEE/ACM IEEE CS, ACM Joint Task Force on Computing Curricula, IEEE Computer Society Press and ACM Press. [online] Available from: http://www.acm.org/education/curricula.html [Accessed: February, 2015]. (2001) 13. Colyer, J.: Making inquiry work in your classroom – OHASSTA [online] Available from http://en.ohassta-aesho.org/wp-content/uploads/2013/09/OHASSTA_2013_Colyer_Inquiry-1.pdf [Accessed: February, 2017]. (2013) 14. Royce, W: "Managing the Development of Large Software Systems", Proceedings of IEEE WESCON, 26 (August): 1–9. (1970) 15. Wing, J. :Computational thinking. Communications of the Association for Computing Machinery, 49(3), 33 (2006) https://doi.org/10.1145/1118178.1118215 16. Wing, J.: Computational thinking. Phil. Trans. R. Soc. A (2008) 366, 3717–3725 doi:10.1098/rsta.2008.0118. (2008a) https://doi.org/10.1098/rsta.2008.0118 17. Wing, J. M. : Five deep questions in computing. Commun. ACM 51, 58–60. (doi:10.1145/1327452.1327479). (2008b) https://doi.org/10.1145/1327452.1327479 18. Hill, G. J: "Review of a problems-first approach to first year undergraduate programming", Software Engineering Education Going Agile: 11th China–Europe International Symposium on Software Engineering Education (CEISEE 2015): Kassel S., Wu B (Eds.), Springer, pp. 73-80, ISBN 978-3-319-29165-9. (2016) https://doi.org/10.1007/978-3-319-29166-6_11 19. Caldwell H and Smith N : Teaching computing? Try switching off your screens[online] https://www.theguardian.com/teacher-network/2017/mar/01/teaching-computing-try-switching-off-your-screens (2017) 20. CAS - Computing At School : QuickStart Computing: A CPD toolkit for primary teachers, CAS, ISBN: 978-1-78339-521-7. (2015a) 21. CAS - Computing At School: Computational thinking: A guide for teachers, CAS, Available: http://community.computingatschool.org.uk/files/6695/original.pdf 22. Smith, N., Sutcliffe, C., & Sandvik, L.: Code club: bringing programming to UK primary schools through scratch. In Proceedings of the 45th ACM technical symposium on Computer science education (pp. 517-522). (2014). https://doi.org/10.1145/2538862.2538919 23. Code Club: Code Club [online] available from: www.codeclub.org.uk [Accessed:Febuary 2017] (NA) 24. Straw, S., Bamford, S. and Styles, B.:. Randomised Controlled Trial and Proces Evaluation of Code Clubs. Slough: NFER. (2016) 25. Shelton, C: "Time to plug back in? The role of "unplugged" computing in primary schools" ITTE Newsletter, Spring (2016)

All views and opinions are the author's and do not necessarily reflected those of any organisation they are associated with. Twitter: @scottturneruon


All views are those of the author and should not be seen as the views of any organisation the author is associated with.

Teaching of Genetic Algorithm with Excel

Originally posted in https://computingnorthampton.blogspot.co.uk/2017/01/genetic-algorithm-teaching-with-excel.html


In a previous post I discussed using Scratch and Excel to model neurones. This post looks at using Excel and six-sided dice as a way of developing insights into how  Genetic Algorithm work, before going on to program one. 

A very simplified version of Tournament Selection is used for the parent selection and the mutation works by rolling a die to get a number between 1-6.

The problem to be solved is to find the lowest values for x and y in the equation 
(x-6)*(x-6)+(y-1)*(y-1).

Routine

1. Using an Excel spreadsheet,  roll two dice six times. Fill in the first two columns with these numbers - these are X and Y values for each solution.
2. The fitness scores should be calculated based on the equation. Low values for this problem are best.
3. 1^st Parent: Roll two dice, if the numbers are same reroll one die to until the numbers are different. Use the two values to select the 1^st parent, the solution with the lowest fitness of the two. Take the X part of the selected parent and it forms the X part of the new child solutions.
4. 2^nd Parent: Roll two dice, if numbers are the same or appear in 1^st parent, reroll until you get two different numbers (including different to the 1^st parent). the solution with the lowest fitness of the two. Take the Y part of the selected parent and it forms the Y part of the new child solution.
5. Mutation: Roll a die for each part of the child solutions. If the roll is 1, roll another die and replace the appropriate element with the new number – even if the same as the previous value.
6. Copy the average  into the table and the lowest value 

7. Copy the child solutions after mutation (orange) into the yellow area and repeat steps 1-6 10 times 

All views and opinions are the author's and do not necessarily reflected those of any organisation they are associated with. Twitter: @scottturneruon

Thomas's Tangle updated - plugged and unplugged

This simplifies the algorithm Thomas' Tangles (named after my son who helped develop it) in Chapter 3 of the book discussed in http://compuationalthinking.blogspot.co.uk/2016/11/how-to-be-unplugged-artist.html

Using crayons, pencils or pens, we are going to follow an algorithm to create a random drawing. This could be done in pairs and you will need squared paper.

Person A: Rolls the dice and reads out the instructions - their role is to roll the dice, interpret the algorithm and tell the 'robot' what to do.

Person B: Is the ‘robot carrying out the instructions'. The lines are solid blocks of colour so move four squares does also mean colour in the squares between the start and finish in the direction of movement.

When a new central square is needed the roles of A and B swap (so A is the ‘robot’ and B rolls the dice and reads out the instruction). The roles keep swapping.

Algorithm

Start from a random square – call it the centre square

Repeat until end of game

If die roll = 1

Roll die for number of moves

move die roll number of steps up the page

If die roll = 2

Roll die for number of moves

move die roll number of steps down the page

If die roll = 3

Roll die for number of moves

move die roll number of steps to the left

If die roll = 4

Roll die for number of moves

move die roll number of steps to the right

If die roll = 5

Roll die

If die = 1 change colour to Red

If die = 2 change colour to Blue

If die = 3 change colour to Black

If die = 4 change colour to Green

If die = 5 change colour to Orange

If die = 6 change colour to Yellow

If die roll = 6

Roll die

Return to current centre square

If the second die roll=6

randomly select new centre square

if block is off the page

randomly select new centre square

The Scratch version can be here https://scratch.mit.edu/projects/135816631/  if you wish to see the code or by clicking below to play it.





All views are those of the author and should not be seen as the views of any organisation the author is associated with.

Training a Neuron using Scratch

In a previous post http://compuationalthinking.blogspot.co.uk/2016/11/artificial-neuron-in-scratch.html I used Scratch to build a working artificial neuron.

In this post, the training of a neuron all written in Scratch is tackled. The video shows it action and you can have a go at using the software yourself at the end of the post. The Scratch code can be found at https://scratch.mit.edu/projects/132915502/




All views are those of the author and should not be seen as the views of any organisation the author is associated with.

Computer Science for Fun - cs4fn: cs4fn Magazine+: Issue 22 Creative Computing

Computer Science for Fun - cs4fn: cs4fn Magazine+: Issue 22 Creative Computing:

cs4fn Magazine+: Issue 22: Computing Sounds Wild

ISSN 1754-3657 (Print)

ISSN 1754-3665 (Online)

A pdf is available to download for free from our download site.

'via Blog this' All views and opinions are the author's and do not necessarily reflected those of any organisation they are associated with. Twitter: @scottturneruon

Artificial Neuron in Scratch

Instructions:

• Set the inputs by pressing the buttons marked input 1 and input 2 (Red is off(False or 0) and Green is on(True or 1))
• Change the weights by changing weights 1 to 3, wx goes with input x and weight 3 is the bias.
• To activate the neuron you need to click on the the yellow ball ('the neuron').

The video below show it in action and explains the code.



All views are those of the author and should not be seen as the views of any organisation the author is associated with.

How to be an Unplugged Artist

Original post at: https://computingnorthampton.blogspot.co.uk/2016/11/how-to-be-unplugged-artist.html

A recently released book Teaching Computing Unplugged in Primary Schools  edited by Helen Caldwell (University of Northampton) and Neil Smith (Open University) has a number of interesting chapters by authors who are passionate about how computing is taught in schools. The central theme is unplugged activities, without using computers, but still teach the fundamental of computational thinking.

Ok, confession time. I co-wrote, along with Katharine Childs (Code Club), Chapter 3 Artists so I am biased here, but I believe in the central theme of Unplugged Computing. Computing, and Computational Thinking in general,  is not just about programming and using a computer (though using computers and  programming are vitally important to Computing) but it is also about many other things including problem-solving, being creative and working collaboratively.

Chapter 3 is about linking these computational thinking ideas to produce visual art, by applying computing principles including  repetition, following and refining algorithms, and abstraction. The chapter also looks, how these links have already being made, with examples such Sol Le Witt where not all the work that was produced by the artist himself, but some by others following his written instructions - in other words an algorithm. There is even a game Thomas's Tangles

The other chapters make links with areas such as Robots, Musicians, Explorers, Magicians, Gamers, Cooks and Scientists.

References

Barr, D., Harrion, J., and Conery, L. (2011) Computational Thinking: A Digital Age Skill for Everyone Leading and Learning with Technology, ISTE, March/April 2011 [accessed via http://www.csta.acm.org/Curriculum/sub/CurrFiles/LLCTArticle.pdf on 26/12/2015]

Barr, V. and Stephenson, C. (2011) Bringing Computational Thinking to K-12, ACM Inroads, Vol 2. No 1, pp 48 - 54 [accessed via http://csta.acm.org/Curriculum/sub/CurrFiles/BarrStephensonInroadsArticle.pdf on 26/12/2015] https://doi.org/10.1145/1929887.1929905

Computing at School (2013) Computing in the National Curriculum: A guide for primary teachers [accessed via http://www.computingatschool.org.uk/data/uploads/CASPrimaryComputing.pdf on 13/3/2016]

Denning, Peter J. (2009) Beyond Computational Thinking, Communications of the ACM Vol 52, Issue 6, pp 28 - 30 [accessed via http://sgd.cs.colorado.edu/wiki/images/7/71/Denning.pdf on 26/12/2015]

DfE: Department for Education (2013) National Curriculum in England: computing programmes of study

Freedman, J. (2015) Cycloid Drawing Machine [online] URL: https://www.kickstarter.com/projects/1765367532/cycloid-drawing-machine accessed on 3/3/2016.

Google. 2016 Project Jacquard [online] URL: https://www.google.com/atap/project-jacquard/ accesed on:1/3/2016.

Knuth, D. 1968. Preface, The Art of Programming vol 1., Boston: Addison-Wesley.

Knuth, D. 1996. Foreword. In: Petkovsek, M., Wilf, H., Zeilberger, D. A=B.. Natick: A K Peters/CRC Press, vii.

Koetsier, T., 2001. On the prehistory of programmable machines: Musical automata, looms, calculators. Mechanism and Machine Theory, 36(5), 589-603. https://doi.org/10.1016/S0094-114X(01)00005-2

Menegus, B (2016) CDMS: Built with Processing [online] URL: http://wheelof.com/sketch/ accessed on 4/3/2016

MoMA. 2012. MoMA| Video Games [online] URL: http://www.moma.org/explore/inside_out/2012/11/29/video-games-14-in-the-collection-for-starters/ accessed on: 1/3/2016.

Papert, S (1993) The children's machine: Rethinking schools in the age of the computer. New York: Basic books

Pearson M (2011) Generative Art: A practical guide using Processing, New York: Manning, 3-12

Selby, C. and Woollard, J. (2013) Computational thinking: the developing definition University of Southampton [accessed via http://eprints.soton.ac.uk/356481/7/Selby_Woollard_bg_soton_eprints.pdf on 26/12/2015]

The Art Story (2016) Sol LeWitt [online] http://www.theartstory.org/artist-lewitt-sol.htm accessed on: 6/3/2016

Wing, J. (2006) Computational Thinking Communications of the ACM Vol 49 pp 33 - 35 [accessed via https://www.cs.cmu.edu/~15110-s13/Wing06-ct.pdf on 26/12/2015] https://doi.org/10.1145/1118178.1118215

Wing, J. (2011) Computational Thinking - What and Why The Link - News from the School of Computer Science, Issue 6.0, Spring 2011 [accessed via http://www.cs.cmu.edu/sites/default/files/11-399_The_Link_Newsletter-3.pdf on 26/12/2015]

Liukas L (2015) Activity 7 The Robots Hello Ruby - Adventures in Coding, New York: Feiwel and Friends, 94-97.

Schofield, S (2016) Generative Artworks [online] URL: http://www.simonschofield.net

Turner S (2016) 3 'Art' Scratch Projects [online] URL: http://compuationalthinking.blogspot.co.uk/2016/03/3-of-my-scratch-projects-for-week.html accessed on: 12/3/2016.

All views and opinions are the author's and do not necessarily reflected those of any organisation they are associated with. Twitter: @scottturneruonAll views are those of the author and should not be seen as the views of any organisation the author is associated with.

Microbit and junkbot?

What is a Junkbot?

For this project, it is a moving ‘bot’ made from waste materials, combined with an electric motor and a programmable device (in this case a Micro:Bit) to control (or try) it. An example is shown below. More details on junkbots can be found at http://junkbots.blogspot.co.uk/

Stage 1 - The start of a Junkbot

This stage is relatively simple. Tape some pens or straws to a drinks can.

Stage 2 - Physical arrangement of Microbit and motor control board

The control part is this via a Micro:bit (http://www.bbc.co.uk/programmes/articles/4hVG2Br1W1LKCmw8nSm9WnQ/the-bbc-micro-bit). Kitronik produce a motor driver board, and provide quite a bit of support for it, for the Micro:Bit (the latest version of the board can be found at https://www.kitronik.co.uk/5620-motor-driver-board-for-the-bbc-microbit-v2.html ). A 6v battery pack is connected (see on the left of the image) and wires going to a motor are attached to the first block on the front left (marked as motor A).

The overall arrangement is show below, including a broken propellor as an unbalanced load to make the motor vibrate - the propellor was to hand but if you can secure something a clothes peg this could be used.

Stage 3 - Built Junkbot
Now we just need to put them together by taping (or fixing somehow) the motor to the junkbot built in stage 1. A further possibility is to attach the Micro:Bit, motor driver board and battery pack to the junkbots; but this adds weight.

Stage 4 Code
 Using Micropython via the online editor https://www.microbit.co.uk to program the board and therefore the junkbot. 

An example piece of code is shown below:

from microbit import *

def startIt():

   pin8.write_digital(1)

   pin12.write_digital(0)

   pin0.write_digital(1)

   pin16.write_digital(0)    

def leftTurn(duration):

   pin8.write_digital(0)

   pin12.write_digital(1)

   sleep(duration)

   

def stopIt():

   pin8.write_digital(1)

   pin12.write_digital(1)

   sleep(2000)

while True:

   startIt()

   

   if button_a.is_pressed():

       leftTurn(100)

   

   if button_b.is_pressed():

       stopIt()

Unplug the Micro:bit from the motor driver board and download the code to the microbit. Unplug the download cable and plug the Micro:Bit back into the motorboard, with the battery pack attached there is enough power for the Micro:Bit and the motor - don't plug in any other power including the programming cable when it is in the motor driver board.


Stage 5 In action

Suggested Resource List

• Small Electric Motor
• Kitronik Motor Board
• Battery Pack
• BBC Micro:bit
• Pens
• Junk (Can or Bottle)
• Wires
• Tape
• Scissors
• Broken Propeller or un-balanced load
• Screw Driver

Stage 6: More control
In the remained of this post I want to show a modification to it, to use one Micro:Bit to control the junkbot controlled by another Micro:Bit. A nice feature of the Micro:Bit using micropython, is it can send and receive simple messages via radio - so here is my take on it.

The first problem is the Python editor available on https://www.microbit.co.uk/ does not seem to work with the radio API. One solution to this is to change to the mu editor.

Two pieces of code are needed.

Stage 7 Sending Code for the 'remote' control:
Essentially it is set up to send two messages, via the built-in radio module, spinl or spinr depending on which button is pressed.

import radio
from microbit import button_a, button_b

radio.on()

while True:
   if button_a.is_pressed():
       radio.send('spinl')
   if button_b.is_pressed():

       radio.send('spinr')

Satge 8 Junkbot Code
This takes an adapted form of the previous Junkbot code to work by; on receiving spinl or spinr via the radio link; spin the motor clockwise or anticlockwise.
import radio
from microbit import pin8, pin12, sleep

def leftTurn(duration):
   pin8.write_digital(0)
   pin12.write_digital(1)
   sleep(duration)
   
def rightTurn(duration):
   pin8.write_digital(1)
   pin12.write_digital(0)
   sleep(duration)
   
def stopIt():
   pin8.write_digital(0)
   pin12.write_digital(0)

radio.on()
while True:
   incoming = radio.receive()
   if incoming == 'spinl':
        leftTurn(500)
        stopIt()
   if incoming == 'spinr':
        rightTurn(500)
        stopIt()







All views are those of the author and should not be seen as the views of any organisation the author is associated with.

Traffic Lights

Ok, one of my quirks is I think the programming exercise of programming simulated traffic lights is fun and interesting! Here are two examples; the first in Scratch and the second using a BBC Micro:bit and GlowBugs (programmable LEDs).



All views are those of the author and should not be seen as the views of any organisation the author is associated with.

Review of a Problems-First Approach to Programming

Review of a Problems-First Approach to First Year Undergraduate Programming - Springer: 



Gary J. Hill   


Published in Software Engineering Education Going Agile Part of the series Progress in IS pp 73-80

DOI 10.1007/978-3-319-29166-6_11

This paper, predominantly discusses the teaching of programming and problem solving to undergraduate first year computing students, using robots/robot simulators and visual programming to emulate the robot tasks. The needs to focus initial programming education on problem solving, prior to the teaching of programming syntax and software design methodology is also considered. The main vehicle for this approach is a robot/robot simulation programmed in Java, followed by the programming of a visual representation/simulation to develop programming skills.



References

1. 1.
   Beaumont, C., and Fox, C.: Learning programming: Enhancing quality through problem-based learning. In: Proceeding of 4th Annual Conference of the subject centre for Information and Computer Sciences of the Higher Education Academy (pp. 90-95). Newtownabbey, Northern Ireland: Higher Education Academy (2003).
2. 2.
   Hill G. J., Turner S.: Chapter 7:​ Problems First. In: Software Industry-Oriented Education Practices and Curriculum Development: Experiences and Lessons, M Hussey, X Xu & B Wu (Eds.), IGI Global, USA, pp 110-126, ISBN: 978-1-60960-797-5 (2011).
3. 3.
   Hill, G., Turner, S. J.: Problems first, second and third. In: International Journal of Quality Assurance in Engineering and Technology Education (IJQAETE). 3(3), pp. 88-109. 2155-496X (2014).
4. 4.
   Williams, A. B.: The qualitative impact of using Lego Mindstorms robot to teach computer engineering. In: Institute of Electrical and Electronic Engineering (IEEE) Transactions on Education, 46, 206 (2003).
5. 5.
   Štuikys, V., Burbaitė, R., Damaševičius, R.: Teaching of Computer Science Topics Using Meta-Programming-Based GLOs and LEGO Robots. In: Informatics in Education - An International Journal (Vol12_1), pp125-142 (2013).
6. 6.
   Kariyawasam, K., A., Turner, S., Hill, G.: Is it Visual? The importance of a Problem Solving Module within a Computing course. In: Computer Education, Volume 10, Issue 166, May 2012, pp. 5-7, ISSN: 1672-5913 (2012).
7. 7.
   HEA-ICS Development Fund: HEA-ICS Development Fund [online] Available from: http://​www.​ics.​heacademy.​ac.​uk/​projects/​development-fund/​index.​php[Accessed: February 2015] (2015).
8. 8.
   HEA-ICS/Microsoft Innovative Teaching Fund: Developing problem-solving teaching materials based upon Microsoft Robotics Studio [online] Available from: http://​www.​ics.​heacademy.​ac.​uk/​projects/​development-fund/​fund_​details.​php?​id =​ 88 [Accessed February 2015] (2015).
9. 9.
   Adams, J. P., & Turner, S. J.: Problem Solving and Creativity for Undergraduate Engineers: process or product? In: International Conference on Innovation, Good Practice and Research in Engineering Education July 14-16, 2008, Loughborough, England, Higher Education Academy. 9781904804659 (2008).
10. 10.
    Adams, J., Turner, S., Kaczmarczyk, S., Picton, P., & Demian, P.: Problem solving and creativity for undergraduate engineers: Findings of an action research project involving robots. In: International Conference on Engineering Education (ICEE 2008), Budapest, Hungary (2008).
11. 11.
    Turner S., Hill G. J.: Robots in Problem-Solving and Programming. In: 8th Annual Conference of the Subject Centre for Information and Computer Sciences, University of Southampton, 28th - 30th August 2007, pp 82-85 ISBN 0-978-0-9552005-7-1 (2007).
12. 12.
    Gallopoulos, E., Houstis, E., Rice, J. R.: Computer as Thinker/Doer. In: Problem-Solving Environments for Computational Science, IEEE Computational Science and Engineering pp 11-23 (1994).
13. 13.
    Houghton, W.: How can Learning and Teaching Theory assist Engineering Academics? [online] School of Engineering - University of Exeter. Available from: https://​www.​heacademy.​ac.​uk/​sites/​default/​files/​learning-teaching-theory.​pdf [Accessed: November 2015] (2004).
14. 14.
    Bloom, B. S. (Ed.): Taxonomy of educational objectives. In: Handbook I: Cognitive domain. White Plains, NY: Longman (1956).
15. 15.
    JICC5: Java & the Internet in the Computing Curriculum, Higher Education Academy (HEA) – Information and Computer Sciences (ICS) Conference, South Bank University, London, 22nd Jan, [online] Available from: http://​www.​ics.​heacademy.​ac.​uk/​events/​displayevent.​php?​id=​127[Accessed: February 2015] (2001).
16. 16.
    Computing Curricula: IEEE CS, ACM Joint Task Force on Computing Curricula, IEEE Computer Society Press and ACM Press. [online] Available from http://​www.​acm.​org/​education/​curricula.​html [Accessed: February, 2015] (2001).
17. 17.
    Koulouri, T., Lauria, S., Macredie, R., D.: Teaching introductory programming: A quantitative evaluation of different approaches. In: ACM Trans. Comput. Educ. 14, 4, Article 26 (December 2014), 28 pages, DOI: http://​dx.​doi.​org/​10.​1145/​2662412 (2014).
18. 18.
    Turner S., Hill G. J.: The Inclusion of Robots Within The Teaching OF Problem Solving: Preliminary Results. In: 7th Annual Conference of the ICS HE Academy, Trinity College, Dublin, 29th - 31st August 2006, Proceedings pg 241-242 ISBN 0-9552005-3-9 (2006).
19. 19.
    Turner S., Hill G. J.: Robots within the teaching of Problem-Solving. In: ITALICS, HEA-ICS, Volume 7 Issue 1, June 2008, pp. 108-119, ISSN: 1473-7507 (2008).
20. 20.
    Turner S., Hill G. J.: Innovative Use of Robots and Graphical Programming in Software Education. In: Computer Education, Volume 9, May 2010, pp. 54-6, ISSN: 1672-5913 (2010).
21. 21.
    Turner S, Hill G, Adams: Robots in problem solving in programming. In: 9th 1-day Teaching of Programming Workshop, University of Bath, 6th April 2009 (2009).
22. 22.
    Gold. N.: Motivating Students in Software Engineering Group Projects: An Experience Report. In: Innovation in Teaching and Learning in Information and Computer Sciences 9(1), 10-19. DOI: 10.11120/ital.2010.09010010 (2010).
23. 23.
    Greenfoot: Teach and Learn Java Programming. [online] Available from http://​www.​greenfoot.​org/​ [Accessed: February 1, 2015] (2015).
24. 24.
    Microsoft: Microsoft robotics studio [online] Available from: http://​msdn2.​microsoft.​com/​en-us/​robotics/​aa731520.​aspx [Accessed: February 2015] (2006).
25. 25.
    Chickering, A. W., Gamson. Z. F.: Seven Principles for Good Practice in Undergraduate Education. In: AAHE Bulletin 39:3-7. ED 282 491.6 pp. MF-01; PC-01 (1987).
26. 26.
    Savin-Baden, M. & Wilkie, K.: (eds) Challenging Research in Problem-based Learning. Maidenhead: Open University Press/SRHE (2004).

To read more go to: Review of a Problems-First Approach to First Year Undergraduate Programming - Springer


'via Blog this'

Posting on the site does not imply endorsement in any way, by the blog owner or any organisations the blog owner is associated with.


If you'd like to find out more about Computing at the University of Northampton go to: www.computing.northampton.ac.uk. All views and opinions are the author's and do not necessarily reflected those of any organisation they are associated withAll views are those of the author and should not be seen as the views of any organisation the author is associated with.