Elsevier

Computers & Education

Volume 95, April 2016, Pages 202-215
Computers & Education

Exploring students' computational practice, design and performance of problem-solving through a visual programming environment

https://doi.org/10.1016/j.compedu.2016.01.010Get rights and content

Highlights

  • A visual problem-solving environment was proposed to support programming learning.

  • Students exhibited different patterns of computational practice in the environment.

  • Patterns of computational practice were correlated with computational design and performance.

Abstract

This study aims to advocate that a visual programming environment offering graphical items and states of a computational problem could be helpful in supporting programming learning with computational problem-solving. A visual problem-solving environment for programming learning was developed, and 158 college students were conducted in a computational problem-solving activity. The students' activities of designing, composing, and testing solutions were recorded by log data for later analysis. To initially unveil the students' practice and strategies exhibited in the visual problem-solving environment, this study proposed several indicators to quantitatively represent students' computational practice (Sequence, Selection, Simple iteration, Nested iteration, and Testing), computational design (Problem decomposition, Abutment composition, and Nesting composition), and computational performance (Goal attainment and Program size). By the method of cluster analysis, some empirical patterns regarding the students' programming learning with computational problem-solving were identified. Furthermore, comparisons of computational design and computational performance among the different patterns of computational practice were conducted. Considering the relations of students' computational practice to computational design and performance, evidence-based suggestions on the design of supportive programming environments for novice programmers are discussed.

Introduction

Programming has been recognized as one of the important competencies that require students to use computational tools to address real-world problems in the 21st century (Einhorn, 2011, Grover and Pea, 2013, Yen et al., 2012). Learning programming is not only a prerequisite for becoming a computer scientist, but it is also necessary for the practice of solving problems and designing systems (Palumbo, 1990, Robins et al., 2003). Programming requires programmers to plan solutions to problems, precisely transform the plans into syntactically correct instructions for execution, and assess the consequent results of executing those instructions (Brookshear, 2003, Deek, 1999, Ismal et al., 2010). However, research revealed that at the conclusion of introductory programming courses, most students have difficulties in decomposing problems, developing plans and implementing their plans with programming languages to solve programming problems (Lister et al., 2004, McCracken et al., 2001, de Raadt, 2007, Robins et al., 2003). Some of them lack adequate understanding of fundamental programming constructs, and most of them lack strategies for transforming programming problems into workable plans and algorithms (Deek, 1999, Kessler and Anderson, 1986, Li and Watson, 2011, de Raadt, 2007). This may be because the formal instruction in programming mostly focuses on students' mastery of a general-purpose programming language and adopts a programming tool that is intentionally designed for professional programmers (Deek, 1999, Ismal et al., 2010, Linn and Clancy, 1992, Robins et al., 2003, Xinogalos, 2012). The employment of the general-purpose programming language and the professional programming tool often drives the teachers and students to invest their efforts more on mastering programming language features than on developing design strategies for solving programming problems (Brusilovsky et al., 1997, Deek, 1999, Linn, 1985, Pears et al., 2007).

Numerous studies have been devoted to research on instructional and environmental assistance for programming learning (Kelleher and Pausch, 2005, Winslow, 1996). Among the studies aiming to devise potential means for enhancing programming, an alternative approach to engaging students in solving computational problems (Edmonds, 2008) has been recognized as an effective way of cultivating students' programming constructs and skills (Liu et al., 2011, Ring et al., 2008). This method often provides students with computational problems, which are specially designed to foster specific programming concepts or skills. In a scenario requiring students to solve a computational problem by exercising various programming knowledge and strategies, the students are expected to learn by formulating computer programs and systematically evaluating the consequent results (Deek, 1999). Many studies have also proposed alternative approaches to the students' difficulties in programming by the use of visual programming environments, such as Scratch and Alice (Cooper et al., 2000, Maloney et al., 2010), LighBot and PlayLOGO 3D (Gouws et al., 2013, Paliokas et al., 2011), or objectKarel and Jeroo (Sanders and Dorn, 2003, Xinogalos, 2012). These environments often adopt different visual programming elements that help novice programmers construct their programs or understand the process of program execution and the state of a problem (Green and Petre, 1996, Kelleher and Pausch, 2005, Navarro-Prieto and Canas, 2001). Research has revealed that visual programming environments could enhance novice programmers' engagement in programming tasks and help them demonstrate programming skills and problem solving strategies during the course of creating digital artifacts or solving programming problems (Cooper et al., 2000, Lye and Koh, 2014). Although visual programming environments are becoming important and have demonstrated their particular benefits to assist learning programming and problem solving (Lye & Koh, 2014), little is known about how novice programmers use a visual programming environment to learn to solve computational problems. Moreover, because constructing a computer program to solve a computational problem in a visual programming environment requires novice programmers to manipulate visual programming elements (e.g., control-flow blocks) to formulate and test a design solution to the problem (e.g., Gouws et al., 2013, Maloney et al., 2010), the programmers' behavior and strategies of solving computational problems in a visual programming environment may affect their performance of problem solving. Therefore, there is a need to further explore the novice programmers' behavioral patterns in a visual programming environment and investigate the difference in their strategies and performance of solving computational problems among different behavioral patterns.

Based on the aforementioned rationale, the purpose of this study is twofold. The first is to develop a visual problem-solving environment for programming learning and explore how novice programmers use it to learn to solve computational problems through interacting with the provided visual programming elements. To understand how novice programmers interact with the proposed environment to solve computational problems, the second purpose is to investigate novice programmers' visual programming behavior and strategies of computational problem-solving enacted in the visual problem-solving environment, as well as to examine the performance of computational problem solving among different patterns of visual programming behavior in computational problem solving activities. To this end, this study aims to answer the following research questions:

  • What are the novice programmers' patterns of visual programming behavior exhibited in a visual programming environment to solve computational problems?

  • Do the novice programmers' computational design and performance of solving computational problems differ in different patterns of visual programming behavior?

The results of this study may be of interest to interface designers attempting to design a specific programming learning environment for novice programmers. The results may also particularly interest teachers or educators who design formal instruction for students to foster their programming strategies (de Raadt, Watson, & Toleman, 2009) or computational problem solving skills.

Section snippets

Programming learning in visual programming environments

Many visual programming environments have been developed to provide novice programmers with visual supports in constructing programs and understanding programming constructs. For example, ToonTalk enables a programming environment in which users interact with visual objects, such as birds or cars in a city, to construct programs (Kahn, 1996). These visual objects may assist users in understanding their programs by examining the state (e.g., appearance, behavior, or location) of the visual

The visual problem-solving environment for programming learning

There are many types of visual programming environments for novice programmers that highlight the distinct benefits to programming behaviors and problem-solving strategies. Nevertheless, this study focuses on the exploration of how novice programmers use the provided visual programming elements to learn by solving a computational problem. To explore novice programmers' visual programming behaviors and strategies, a visual problem-solving environment for programming learning was specifically

Descriptive statistics of the computational problem-solving activities

Table 2 reveals the descriptive statistics of 10 indicators regarding the computational problem-solving activities. With regard to the dimension of computational practice, the results showed that the participants used more simple iteration (M = 8.56, SD = 4.13) and sequence (M = 4.84, SD = 3.33) than selection (M = 2.04, SD = 4.83) and nested iteration (M = 1.25, SD = 1.87) control-flow blocks in solving the computational problems. The results also showed that the participants, on average,

Discussion and conclusion

This study proposed a visual problem-solving environment aiming to assist students' programming learning by analyzing, designing, implementing, and evaluating solutions to computational problems. Because many studies have suggested the potential of visual programming environments for programming learning (Cooper et al., 2000, Lye and Koh, 2014, Maloney et al., 2010), the visual problem-solving environment proposed in this study further allowed the students to solve computational problems by

Acknowledgements

This research was partially funded by Ministry of Science and Technology, Taiwan, under grant number MOST 103-2511-S-155-001-MY2

References (69)

  • C. Böhm et al.

    Flow diagrams, turing machines, and languages with only tow formation rules

    Communication of the ACM

    (1966)
  • K. Brennan et al.

    New frameworks for studying and assessing the development of computational thinking

  • J.G. Brookshear

    Computer science: An overview

    (2003)
  • P. Brusilovsky et al.

    Mini-languages: a way to learn programming principles

    Education and Information Technologies

    (1997)
  • Code.org

    Hour of Code website

    (2015)
  • S. Cooper et al.

    Alice: 3D tool for introductory programming concepts

    Journal of Computing Sciences in College

    (2000)
  • J.H. Cross et al.

    Using the debugger as an integral part of teaching CS1

  • F.P. Deek

    The software process: a parallel approach through problem solving and program development

    Computer Science Education

    (1999)
  • P. Deitel et al.

    C++ how to program

    (2011)
  • J. Edmonds

    How to think about algorithms

    (2008)
  • S. Einhorn

    Microworlds, computational thinking, and 21st century learning

    (2011)
  • S.B. Fee et al.

    Teaching computer science through problems, not solutions

    Computer Science Education

    (2010)
  • L.P. Flannery et al.

    Designing ScratchJr: support for early childhood learning through computer programming

  • G. Futschek et al.

    Learning algorithmic thinking with tangible objects eases transition to computer programming

    Informatics in Schools, Contributing to 21st Century Education

    (2011)
  • A. Gomes et al.

    An environment to improve programming education

  • J.S. Gourlay

    A mathematical framework for the investigation of testing

    IEEE Transactions of Software Engineering

    (1983)
  • L. Gouws et al.

    Computational thinking in educational activities: an evaluation of the educational game light-bot

  • S. Grover et al.

    Computational thinking in K-12: a review of the state of the field

    Educational Researcher

    (2013)
  • O. Hazzan et al.

    Guide to teaching computer science: An activity-based approach

    (2011)
  • J. Holvikivi

    Conditions for successful learning of programming skills

  • H.-T. Hou

    Integrating cluster and sequential analysis to explore learners' flow and behavioral patterns in a simulation game with situated-learning context for science courses: a video-based process exploration

    Computer in Human Behavior

    (2015)
  • M.N. Ismal et al.

    Instructional strategy in the teaching of computer programming: a need assessment analyses

    The Turkish Online Journal of Educational Technology

    (2010)
  • W.L. Johnson

    Intention-based diagnosis of novice programming errors

    (1986)
  • C. Kelleher et al.

    Lowering the barriers to programming: a taxonomy of programming environments and languages for novice programmers

    ACM Computing Surveys

    (2005)
  • Cited by (122)

    • Effect of augmented reality-based virtual educational robotics on programming students’ enjoyment of learning, computational thinking skills, and academic achievement

      2023, Computers and Education
      Citation Excerpt :

      One plausible reason for the observation regarding problem decomposition skills is that writing computer programs requires students to identify the general problem and then decompose it into manageable pieces of several steps or sub-goals (Shute et al., 2017). Block-based visual tools help decompose problems because visual programming tools allow students to specify a program by dragging and dropping the visual elements instead of entering text-based statements (Chao, 2016). The two CT tools in this study were blocks and visualization, which may assist novices in understanding programming concepts (Chao, 2016), by focusing on decomposing a problem into subproblems.

    View all citing articles on Scopus
    View full text