Pirate plunder: game-based computational thinking using scratch blocks

Policy makers worldwide argue that children should be taught how technology works, and that the ‘computational thinking’ skills developed through programming are useful in a wider context. This is causing an increased focus on computer science in primary and secondary education. Block-based programming tools, like Scratch, have become ubiquitous in primary education (5 to 11-years-old) throughout the UK. However, Scratch users often struggle to detect and correct ‘code smells’ (bad programming practices) such as duplicated blocks and large scripts, which can lead to programs that are difficult to understand. These ‘smells’ are caused by a lack of abstraction and decomposition in programs; skills that play a key role in computational thinking. In Scratch, repeats (loops), custom blocks (procedures) and clones (instances) can be used to correct these smells. Yet, custom blocks and clones are rarely taught to children under 11-years-old. We describe the design of a novel educational block-based programming game, Pirate Plunder, which aims to teach these skills to children aged 9-11. Players use Scratch blocks to navigate around a grid, collect items and interact with obstacles. Blocks are explained in ‘tutorials’; the player then completes a series of ‘challenges’ before attempting the next tutorial. A set of Scratch blocks, including repeats, custom blocks and clones, are introduced in a linear difficulty progression. There are two versions of Pirate Plunder; one that uses a debugging-first approach, where the player is given a program that is incomplete or incorrect, and one where each level begins with an empty program. The game design has been developed through iterative playtesting. The observations made during this process have influenced key design decisions such as Scratch integration, difficulty progression and reward system. In future, we will evaluate Pirate Plunder against a traditional Scratch curriculum and compare the debugging-first and non-debugging versions in a series of studies

Relationships: computational thinking, pedagogy of programming, and Bloom’s Taxonomy

This study explores the relationship between computational thinking, teaching programming, and Bloom’s Taxonomy. Data is collected from teachers, academics, and professionals, purposively selected because of their knowledge of the topics of problem solving, computational thinking, or the teaching of programming. This data is analysed following a grounded theory approach. A computational thinking taxonomy is developed. The relationships between cognitive processes, the pedagogy of programming, and the perceived levels of difficulty of computational thinking skills are illustrated by a model. Specifically, a definition for computational thinking is presented. The skills identified are mapped to Bloom’s Taxonomy: Cognitive Domain. This mapping concentrates computational skills at the application, analysis, synthesis, and evaluation levels. Analysis of the data indicates that abstraction of functionality is less difficult than abstraction of data, but both are perceived as difficult. The most difficult computational thinking skill is reported as decomposition. This ordering of difficulty for learners is a reversal of the cognitive complexity predicted by Bloom’s model. The plausibility of this inconsistency is explored. The taxonomy, model, and the other results of this study may be used by educators to focus learning onto the computational thinking skills acquired by the learners, while using programming as a tool. They may also be employed in the design of curriculum subjects, such as ICT, computing, or computer science. <br/

A review and assessment of novice learning tools for problem solving and program development

There is a great demand for the development of novice learning tools to supplement classroom instruction in the areas of problem solving and program development. Research in the area of pedagogy, the psychology of programming, human-computer interaction, and cognition have provided valuable input to the development of new methodologies, paradigms, programming languages, and novice learning tools to answer this demand. Based on the cognitive needs of novices, it is possible to postulate a set of characteristics that should comprise the components an effective novice-learning tool. This thesis will discover these characteristics and provide recommendations for the development of new learning tools. This will be accomplished with a review of the challenges that novices face, an in-depth discussion on modem learning tools and the challenges that they address, and the identification and discussion of the vital characteristics that constitute an effective learning tool based on these tools and personal ideas

An Operationalized Model for Defining Computational Thinking

The Computational Thinking (CT) conceptual framework is entering its second decade of research yet still lacks a cohesive definition by which the field can coalesce. The lack of clear definition makes assessment tool challenging to formulate, pedagogical efforts difficult to compare, and research difficult to synthesize. This paper looks to operationalize differing definitions of CT enhancing the ability to teach then assess the presence of CT. Expanding upon CT definitions, industry practices and processes, and educational theory, we link existing concepts and propose a new element to model an active definition of CT as a theoretical framework to guide future research. Our model updates existing CT definition by formally including Modeling, introducing Socio-Technical processes, separating Information Gathering from Data Collection and adding emphasis to Testing as a vital CT concept. We feel these elements and interconnections make CT is easier to describe and measure

Abstraction in action: K-5 teachers' uses of levels of abstraction, particularly the design level, in teaching programming

Research indicates that understanding levels of abstraction (LOA) and being able to move between the levels is essential to programming success. For K-5 contexts LOA levels have been named: problem, design, code and running the code. In a qualitative exploratory study, five K-5 teachers were interviewed on their uses of LOA, particularly the design level, in teaching programming and other subjects. Using PCK elements to analyse responses, the teachers interviewed used design as an instructional strategy and for assessment. The teachers used design as an aide memoire and the expert teachers used design: as a contract for pair-programming; to work out what they needed to teach; for learners to annotate with code snippets (to transition across LOA); for learners to self-assess and to assess ‘do-ability’. The teachers used planning in teaching writing to scaffold learning and promote self-regulation revealing their insight in student understanding. One issue was of the teachers' knowledge of terms including algorithm and code; a concept of ‘emergent algorithms’ is proposed. Findings from the study suggest design helps learners learn to program in the same way that planning helps learners learn to write and that LOA, particularly the design level, may provide an accessible exemplar of abstraction in action. Further work is needed to verify whether the study's results are generalisable more widely

A document-like software visualization method for effective cognition of c-based software systems

It is clear that maintenance is a crucial and very costly process in a software life cycle. Nowadays there are a lot of software systems particularly legacy systems that are always maintained from time to time as new requirements arise. One important source to understand a software system before it is being maintained is through the documentation, particularly system documentation. Unfortunately, not all software systems developed or maintained are accompanied with their reliable and updated documents. In this case, source codes will be the only reliable source for programmers. A number of studies have been carried out in order to assist cognition based on source codes. One way is through tool automation via reverse engineering technique in which source codes will be parsed and the information extracted will be visualized using certain visualization methods. Most software visualization methods use graph as the main element to represent extracted software artifacts. Nevertheless, current methods tend to produce more complicated graphs and do not grant an explicit, document-like re-documentation environment. Hence, this thesis proposes a document-like software visualization method called DocLike Modularized Graph (DMG). The method is realized in a prototype tool named DocLike Viewer that targets on C-based software systems. The main contribution of the DMG method is to provide an explicit structural re-document mechanism in the software visualization tool. Besides, the DMG method provides more level of information abstractions via less complex graph that include inter-module dependencies, inter-program dependencies, procedural abstraction and also parameter passing. The DMG method was empirically evaluated based on the Goal/Question/Metric (GQM) paradigm and the findings depict that the method can improve productivity and quality in the aspect of cognition or program comprehension. A usability study was also conducted and DocLike Viewer had the most positive responses from the software practitioners

How can the teaching of programming be used to enhance computational thinking skills?

The use of the term computational thinking, introduced in 2006 by Jeanette Wing, is having repercussions in the field of education. The term brings into sharp focus the concept of thinking about problems in a way that can lead to solutions that may be implemented in a computing device. Implementation of these solutions may involve the use of programming languages.This study explores ways in which programming can be employed as a tool to teach computational thinking and problem solving. Data is collected from teachers, academics, and professionals, purposively selected because of their knowledge of the topics of problem solving, computational thinking, or the teaching of programming. This data is analysed following a grounded theory approach. A Computational Thinking Taxonomy is developed. The relationships between cognitive processes, the pedagogy of programming, and the perceived levels of difficulty of computational thinking skills are illustrated by a model.Specifically, a definition for computational thinking is presented. The skills identified are mapped to Bloom’s Taxonomy: Cognitive Domain. This mapping concentrates computational skills at the application, analysis, synthesis, and evaluation levels. Analysis of the data indicates that the less difficult computational thinking skills for beginner programmers are generalisation, evaluation, and algorithm design. Abstraction of functionality is less difficult than abstraction of data, but both are perceived as difficult. The most difficult computational thinking skill is reported as decomposition. This ordering of difficulty for learners is a reversal of the cognitive complexity predicted by Bloom’s model. The plausibility of this inconsistency is explored.The taxonomy, model, and the other results of this study may be used by educators to focus learning onto the computational thinking skills acquired by the learners, while using programming as a tool. They may also be employed in the design of curriculum subjects, such as ICT, computing, or computer science

Using Pirate Plunder to develop children’s abstraction skills in Scratch

Scratch users often struggle to detect and correct ‘code smells’ (bad programming practices) such as duplicated blocks and large scripts, which can make programs difficult to understand and debug. These ‘smells’ can be caused by a lack of abstraction, a skill that plays a key role in computer science and computational thinking. We created Pirate Plunder, a novel educational block-based programming game, that aims to teach children to reduce smells by reusing code in Scratch. This work describes an experimental study designed to measure the efficacy of Pirate Plunder with children aged 10 and 11. The findings were that children who played the game were then able to use custom blocks (procedures) to reuse code in Scratch, compared to non-programming and programming control groups

Introductory programming: a systematic literature review

As computing becomes a mainstream discipline embedded in the school curriculum and acts as an enabler for an increasing range of academic disciplines in higher education, the literature on introductory programming is growing. Although there have been several reviews that focus on specific aspects of introductory programming, there has been no broad overview of the literature exploring recent trends across the breadth of introductory programming. This paper is the report of an ITiCSE working group that conducted a systematic review in order to gain an overview of the introductory programming literature. Partitioning the literature into papers addressing the student, teaching, the curriculum, and assessment, we explore trends, highlight advances in knowledge over the past 15 years, and indicate possible directions for future research

A Novice's Process of Object-Oriented Programming

Exposing students to the process of programming is merely implied but not explicitly addressed in texts on programming which appear to deal with 'program' as a noun rather than as a verb.We present a set of principles and techniques as well as an informal but systematic process of decomposing a programming problem. Two examples are used to demonstrate the application of process and techniques.The process is a carefully down-scaled version of a full and rich software engineering process particularly suited for novices learning object-oriented programming. In using it, we hope to achieve two things: to help novice programmers learn faster and better while at the same time laying the foundation for a more thorough treatment of the aspects of software engineering