Review of a Problems-First Approach to First Year Undergraduate 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., & 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 with

new JunkBot interface for Primary Education (updated with videos)

Copyright Scott turner

Cross posted with http://junkbots.blogspot.co.uk/2015/07/see-junkbot-interface-for-primary.html

The aim of the project is to give students in Primary Education an introduction to programming principles and basic programming language structure via physical feedback, in the shape of robotics. To do this, research and development into available methods currently available toke place, possibilities to do with JunkBot programming such as JunkBots using Scratch and other potential languages were explored and developed upon.

History of JunkBots

The JunkBot concept originally comes from the University of Northampton JunkBots Project[1]. The aim of the concept is to introduce the concept of Environmental Sustainability through the use of recycling “junk” to create the JunkBots and introduce computing and engineering to students. JunkBots were selected for this project due to several factors. Firstly, they are cost effective ways of delivering fun, creative ways of teaching computing and engineering principles to young students. JunkBots also have scope to be flexible, in terms of creativity and scope for more developments upon the existing concept. JunkBots vary in terms of design however all have the same factor in common; they are powered by a motor of some sort. The design does have an impact on the functionality of the bot, for example a robot with pens can draw whereas a robot that has an eraser attached to it can potentially rub out. The flexibility and creativity ties in with the project aims. 

Summary 

Copyright James Mitchell

The project overall flowed as one major project with sub-stages, these came in the form of Scratch, Python and the Blockly stage. Before these stages could be advanced onto, initial research and experimentation was carried out. The case study of existing projects, such as the JunkBot concept were investigated into. As the project was to be based around JunkBots and education, surveys were carried out in order to provide a base set of requirements and an understanding of what needed specifically to be developed. Once this was achieved, concepts and already existing developments with JunkBots were researched into. This involved Scratch, Raspberry Pi and JunkBots which led to the Scratch stage of the project. The author did not develop this stage, which meant that it was simply a base to work from. The findings from this section led on to the Python implementation due to its high level programming nature in a simple formed syntax, unlike other similar languages such as Java, C++. It was found during research and both experimentation of the Python language, that the language principles of Python and simple syntax structure are essential elements in an Educational environment, which showed that to be successful the project from that point needed to implement a similar Scratch-like concept, in the form of a graphical programming interface to be successful.

The Python implementation was primarily a stepping stone to achieving the
graphical programming interface element, as it would be used in conjunction with the final stage, Blockly to achieve the required specification and combine the findings from the Python Implementation with Scratch via Blockly. The findings from the Python implementation showed that on its own, being a completely code-based implementation and had no graphical programming meant that a combination between Blockly and Python was needed. The Python implementation itself was successful and led on to the final development stage of the project, Blockly.

Copyright James Mitchell

The Blockly stage involved utilizing the Blockly platform to implement the Python solution with both a graphical programming style and allow for the use of code unlike Scratch. This proved success, providing both a graphical programming interface which generated code based on the Block structure. This implementation adhered to the original requirements found via surveys and research initially, which were to provide Primary Education with a physical entity that could be programmed via a graphical interface in order to teach programming principles. The application also had to allow creativity for experimentation and logical/computational thinking. A key focus on both graphical and having a physical feedback element are the key points for a successful implementation. The findings of the Blockly stage were a success, as the implementation provided a fit for purpose product and also was found to adhere to relevant points of the Computing National Curriculum for both Key Stage 1 and 2 as set out in Section 1.2, National Curriculum Changes.

The Blockly application itself is considered by the author as a development rather than a finished product, which means the application can improve certain aspects. The main improvement that can now be fulfilled as the initial implementation is complete, is the creation of a standalone application to implement Blockly inside of. This is mainly due to accessing direct control of the JunkBot via the application rather than having to use the Raspberry Pi terminal to access Blockly generated code. This can be considered a weakness of the project at its current stage, similar to how the Python implementation was a stepping stone that led to the Blockly application. However, this can also be considered a strong point in regards to the transitional benefit in Education from Scratch based learning to Python. In its current state, the application allows the generation of code via Blocks which can power the JunkBot after placing the code into the appropriate place. This can potentially be taken further in an Educational setting by having activities starting with Scratch and leading up to the Python using Blockly to power the JunkBot and then potentially leading onto actual Python language programming rather than using Blockly. The benefit to this method would be the pupil gets to see the process gradually and gives a reason to write a program to power the JunkBot rather than just learning Python syntaxes. This can be combined with Syntax learning. This also makes the application beneficial between Key Stage 2 and 3 of Education, as the Python language is generally considered to be used more so in Key Stage 3 than Primary Education. This means the application potentially bridges Primary and Secondary Education programming teachings and could even be used at a higher level of Secondary Education.

In addition to a standalone application, further advancements into the development of Blocks to achieve a broader range of uses. This could range from motor control variations to other JunkBot control.

External sources towards the end of the project have had a major interest in the project, for example at a recent BCS Teaching Scholarship interview in Manchester, a recommendation by representatives of BCS stated that "I urge you to continue the work you are carrying out with your dissertation project, as it is a key area of Computing and a very interesting project". Other sources have taken an interest in the project and have requested a copy of the finished project report and have asked for the developed product to be even demonstrated at a Teaching event. This also shows the potential advancements of the project and the need for it to be continued to be developed. The author in conjunction with Dr. Scott Turner also intends to publish both the Blockly application and Python implementation as a ComputingAtSchools (CAS) resource, which is designed as a resource bank for teachers.

In conclusion to the project, the final conclusion is that the overall project was a success. A Blockly-JunkBot application was developed towards and has met all of the requirements originally set out and has proved the concept will be a positive impact on education via testing and review of the application. 

Sources of further information

[1] Turner, Scott. (2013). JunkBots Blog, Available: http://junkbots.blogspot.co.uk/

                                                              

[2] Turner, Scott. (2013). JunkBots Project, Available: http://community.computingatschool.org.uk/resources/1190

[3] Turner, Scott, Teyley, Hayden. (2014). JunkBots Project, Available: http://junkbots.blogspot.co.uk/2014/07/junkbot-project-evolves1-idea.html

[4] Mitchell, James. (2014). Teaching Programming in Education, a study of Physical Computing, Available: https://docs.google.com/forms/d/1PNFH08OOQMeydcvzvco5abG8Zxfy-FwTbxD0eVsw8SY/viewform

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 with

If you would like to know more about the Junkbots project contact scott.turner@northampton.ac.uk

Computational Thinking and Junkbots

A recent presentation as part of the Department of Computing and Immersive Technologies, University of Northampton Research Seminar series, looking a on going project within the Department.

Junkbots has been a ongoing and ever evolving project since 2009 around the use of 'junk' as part of activities to developing skills in STEM subjects. In particular in the presentation (below) shows the links between these activities and Computational Thinking were discussed.

Junkbots and computational thinking from Scott Turner

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 with

Creative Computational Thinking blog

A new blog has been launched by Scott Turner  looking at Computational Thinking (http://compuationalthinking.blogspot.co.uk/ - the typo in the name is there on purpose). As a blog there is not a particular target audience apart from those interested in Computational Thinking or problem-solving.

At the time of writing so far there have been posts on robots, apps, and overview of Computational Thinking.


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 with.

Raspberry Pi Robot from junk

Figure 1

In previous posts the idea of adding some programming into the a 'bot' made of junk, a junkbot, was briefly discussed (http://computingnorthampton.blogspot.co.uk/2014/07/physical-computing-junkbots-with-brain.html) and the use of LEGO to do this was discussed in a recent post (http://computingnorthampton.blogspot.co.uk/2014/08/controlling-lego-junkbot.html)

In this post the aim is to discuss using a Raspberry Pi and Scratch to do this. Including:
- Choice of motor controller card for the 'bot'
- Provide an example of a drawing junkbot controlled through Scratch and Raspberrry Pi


Choice of interface/Controller card
The card choosen was the 4Tronix PiRoCon card  (http://4tronix.co.uk/store/index.php?rt=product/product&product_id=182). Selected for four reasons
- Price is reasonable (in my opinion).
- Fits straight onto the Pi through the GPIO - no extra cables needed.
- ScratchGPIO has it as an addon so it makes programming it even easier (see http://cymplecy.wordpress.com/2013/10/31/pirocon-from-4tronix/).
- Others are using it for robot projects.

Use it is quite easy plug the board directly on to the GPIO connector of the Raspberry Pi (4tronix provide some advice in section 15 of http://4tronix.co.uk/blog/?p=22 on mounting the board). The only other changes that were needed were because the motors were not powered through the DC input jack, changesto the jumper settings next to Vin Connector (see http://4tronix.co.uk/blog/?p=41 for layout)  were neededto reflect this.



Example: Drawing Raspberry Pi Junkbot
Now for the fun bit get the whole thing to draw (see Figure 1 and the video at the end)!

The junkbot itself is made up of a drinks can, three supports (we used LEGO here but it equally could be straws, sticks), a pen/pencil, and a  motor and broken propeller combination to create an unbalanced motor.

With the Raspberry Pi off, the the motor's wires are connected to the controller card at the connections for MotorA and the battery is also connected. Turn the Pi on and run ScratchGPIO5plus.

Figure 2

Figure 3

Figure 4

The first task is to make the variables AddOn (which will be used to tell the program we are using the PiRoCon card) and MotorA for the motor (see Figure 3).

In Figure 4 the program can be seen, essentially the left and right key spin the junkbot clockwise or anticlockwise by setting the Motor to either +ve or -ve values from 0 to 100. The space bar is used to stop the motor.

As it moves because one of the supports is a pen it draws. See the video below to watch it draw a squiggly line - control is still a challenge.
 The bot was developed by Hayden Tetley and Scott Turner. Hayden's time was paid  for through the Nuffield Research Placements  Scheme (http://www.nuffieldfoundation.org/nuffield-research-placements).

Related Links

Junkbot Raspberry Pi: 1 ScratchGPIO 

Junkbot Raspberry Pi: 2 Raspberry Pi Junkbot in action

If you would like to know more about the Junkbots project contact scott.turner@northampton.ac.uk. The views and opinions is the authors and should not be taken as representing the views of any organisation the author is associated with.

Open Educational Resources: Problem-Solving

A new Open Education Resource (OER) has been made available by the Department of Computing and Immersive Technologies, School of Science and Technology, University of Northampton.

Problem-Solving

Author: Dr Scott Turner

http://find.jorum.ac.uk/resources/19001

Details

These mini lectures are intended for undergraduate computing students, for providing simple steps in problem solving before the students learn a programming language. Problem-Solving and Programming is a common first year undergraduate module on the BSc Computing Programme at the University of Northampton. This material was taken from the problem solving part of the module and provides an introduction to five topics in problem-solving.

The resource can be found at: http://find.jorum.ac.uk/resources/19001