Design as a core focus of learning using computational programming and modeling
Sengupta et al. (2013) argued that CT becomes evident only in the form of design-based epistemic and representational practices. Grover and Pea (2013) have identified examples of representational practices as abstractions and pattern generalizations (that include modeling and simulation activities); symbol systems and representations; algorithmic notions of flow of control; structured problem decomposition (modularizing); conditional logic; and iterative, recursive, and parallel thinking. Other epistemic practices include systematic processing of information, adopting efficiency and performance constraints, and debugging and systematic error detection. This, in turn, aligns with the following perspectives:
-
Science as practice perspective (Duschl 2008; Lehrer and Schauble 2006), which suggests that the development of scientific concepts is deeply intertwined with the development of epistemic and representational practices such as modeling. Modeling—i.e., the collective action of developing, testing, and refining models (National Research Council 2008)—involves carefully selecting aspects of the phenomenon to be modeled, identifying relevant variables, developing formal representations, and verifying and validating these representations with the putative phenomenon (Penner et al. 1998; Lehrer and Schauble 2006); and
-
Learning-by-design pedagogy which suggests that students learn best when they engage in the design and consequential use of external representations for modeling and reasoning (Kolodner et al. 2003; Papert 1991).
From a pedagogical perspective, this means that engaging students in developing design-based computational representational practices, such as the ones discussed above, can be closely aligned with the development of students’ CT skills.
Several scholars have pointed out that computing can be used successfully as a medium for teaching and learning other subjects and that this can facilitate learning in both the subject and computing domains. For example, Papert (1991) stated that programming is reflexive with other domains; that is, learning programming in concert with concepts from another domain (such as math and science) can be easier than learning them separately. Kay and Goldberg (1977) showed that object-oriented programming using SmallTalk is useful for learning math, science, and art. Emile, a scaffolded graphical programming interface designed and used to help students learn physics, represents another example of synergistic learning (Guzdial 1994). Redish and Wilson (1993), Soloway (1993), and Kafai et al. (1997) also demonstrated that reorganizing scientific and mathematical concepts around computational mechanisms lowered the learning threshold, especially in domains like physics and biology. More recently, some researchers have exploited the synergy between CT and science to develop CT-based science curricular units for K-12 classrooms (Sengupta et al., 2015; Basu, Kinnebrew & Biswas 2014; Allan et al. 2010; Repenning et al. 2010).
In each of the environments discussed above, students learn through an iterative model building process. Previous studies have shown that middle school and elementary children can successfully use programming as a mode of inquiry to develop models of scientific phenomena, which in turn helps them develop a deep understanding of the relevant scientific concepts (diSessa et al. 1991; Sengupta & Farris 2012). CTSiM adopts this learning-by-design pedagogical approach (Kolodner et al. 2003), and students iteratively design, test, and revise computational models of physics and ecology.
Agent-based modeling can leverage students’ prior knowledge
CTSiM is an agent-based modeling environment. The term “agent” here indicates an individual computational object or actor (for example, a rollercoaster car or a fish in a fish tank), which performs actions (for example, moving forward, changing directions) based on simple rules, and these rules can be designed and controlled by the user. Several researchers have shown that agent-based modeling can leverage K-12 students’ pre-instructional intuitions and support their learning of (a) complex and emergent phenomena in biology, such as population dynamics in ecological systems (Basu et al. (2014); Dickes and Sengupta 2012; Wilensky and Reisman 2006), and (b) phenomena in the domain of Newtonian mechanics that require students to develop an understanding of the relations between position, speed, and acceleration as aggregation of continuous change in these variables over time (Basu et al. 2012; diSessa et al. 1991).
The advantages of visual programming
In a visual programming (VP) environment, students construct programs using graphical objects and a drag-and-drop interface, thus making the programming more intuitive and accessible to the novice programmer (Kelleher and Pausch 2005). Visual constructs significantly reduce issues with program syntax and understanding textual structures making it easier for students to focus on the semantic meaning of the constructs (Soloway 1993). For example, visual interfaces make it easier to interpret and use flow of control constructs, such as loops and conditionals (Parsons and Haden 2007a, b).
CTSiM provides a library of visual constructs that students can choose from and arrange spatially to generate their computational models. If students try to drag and drop a programming construct incorrectly, the system disallows the action and indicates the error by explicitly displaying an “x” sign. Therefore, CTSiM eliminates the possibility of generating programs (that is, models) with syntax errors. Examples of other agent-based VP environments include AgentSheets (Repenning 1993), StarLogo TNG (Klopfer et al. 2005), Scratch (Maloney et al. 2004), ViMAP (Sengupta et al., 2015), and Alice (Conway 1997). They have been used successfully in teaching children CT through game design, storytelling, and modeling activities.
Integration of domain-specific primitives and domain-general abstractions
Previous research suggests that learning a domain-general programming language and then using it for domain-specific scientific modeling involves a significant pedagogical challenge (Guzdial 1994; Sherin et al. 1993). To address this issue, CTSiM combines domain-general and domain-specific primitives. Domain-general primitives are computational constructs (for example, “when-do-otherwise do” and “repeat” representing conditionals and loops). Domain-specific primitives are designed specifically to support modeling of particular aspects of the topic of study, for example, kinematics or ecology. Imposing domain-specific names on the constructs creates semantically meaningful structures for modeling actions in the particular domain. For example, “forward,” “speed up,” and “slow down” represent movement, acceleration, and deceleration actions in kinematics, respectively, and “create new” and “die” imply birth and death of agents in ecology, respectively. Students develop more complex agent behaviors by combining computational and domain-specific primitives. Examples include “model car speed” behavior in kinematics and “breathe” and “eat” behaviors in ecology. Previous studies suggest that such an approach that combines domain-general and domain-specific computational primitives can effectively support the development of children’s scientific models and conceptual understanding of the domain, as well as support the development of their programming concepts and skills.
Known challenges for programming and learning-by-modeling in science
Developing a scaffolding framework for an environment like CTSiM which is intended to be used in classroom settings warrants an in-depth understanding of the different types of difficulties students at different levels of understanding face in the environment (Puntambekar and Hubscher 2005). Previous research has separately documented challenges associated with science learning, programming challenges faced by students and challenges faced with inquiry learning using modeling and simulation. However, when science learning and learning programming skills are combined in a modeling- and simulation-based learning environment, the types of challenges that emerge have not been explored. In this section, we explore the known challenges in each of these areas.
Instructional approaches in science emphasize learning by engaging in knowledge construction practices, investigation, and argumentation. These approaches to learning through inquiry not only provide the potential to connect knowledge more effectively to real-world contexts but also pose particular challenges for learners (Reiser 2004). For example, learners may not be familiar with general strategies for designing empirical tests of hypotheses and in using specific domain knowledge to plan and guide investigations (Schauble et al. 1991). They also tend to focus on achieving desired results rather than on understanding the principles behind the results (Perkins 1998) and find it difficult to generalize appropriately from their work on specific problem scenarios. Further, students tend to have difficulty mapping their intuitive understandings to formal representations and evaluating alternate representations (Sherin 2001). In addition, students may face social interaction and collaboration challenges or linguistic and discourse challenges (Reiser 2004).
The challenges faced in learning science through investigative processes or discovery learning can be grouped in a number of ways. Quintana et al. (2004) categorizes the challenges into three categories, those related to sense making, process management, and articulation and reflection. Sense making entails constructing and interpreting empirical tests of hypotheses. Students need to coordinate their reasoning about experiments or data comparisons with the implications of the findings for an explanation of the scientific phenomena. This coordination and mapping task is complex and requires rich subject matter knowledge to design data comparisons and interpret findings in light of the hypotheses. Process management involves the iterative processes of designing an investigation, collecting data, constructing and revising explanations based on data, evaluating explanations, and communicating arguments. These require both discipline-specific processes and content knowledge that may be new to learners. Finally, scientific investigations require the complementary processes of reflection and articulation as students monitor and evaluate their progress, reconsider and refine their plans, and articulate their understanding as they proceed. Thus, in learning science through inquiry or investigative process, students face challenges at several levels. They face challenges with the content knowledge, as well as the cognitive complexity of discipline-specific strategies for sense making and process management, and the metacognitive processes for social interaction and discourse association with scientific practices (Reiser 2004).
On the other hand, de Jong and van Joolingen (1998) identify a number of characteristic problems that learners may encounter in discovery learning with computer simulations and classify them according to the main discovery learning processes: hypothesis generation, design of experiments, interpretation of data, and regulation of learning. These challenges hold good for discovery learning using computer simulations in any domain including science. Generating hypotheses and adapting or rejecting hypotheses based on collected data seem to be common challenges. Also, students display confirmation bias—the tendency to seek for information confirming hypotheses or construct experiments that are not intended to test a hypothesis. They tend to design inconclusive experiments and show inefficient experimentation behavior. In addition, interpretation of data is often directed by the hypothesis and the tendency to find data confirming the hypotheses. In particular, students find interpretation of graphs extremely difficult. Finally, planning experiments and working in a systematic fashion are processes students find challenging.
Students’ challenges with studying scientific phenomena using a complex systems framework have also been studied extensively. In such systems, the collective, global behavior emerges from the properties of individual elements and their interactions with each other. The global or macro behaviors—known as emergent phenomena—are often, not easily explained by the properties of the individual elements. For example, in chemistry and physics, gas molecules’ elastic collisions at the micro level produce the macro-level properties of pressure and temperature. In biology, animals interact with others of the same and different species and the environment to survive, grow, and reproduce at the individual level that leads to phenomena such as evolution, natural selection, and population dynamics at the ecosystem level. Students find the behaviors of individual elements intuitive but struggle to understand their relations with the aggregate behavior (Wilensky & Resnick 1999; Chi 2005).
Studies have not yet been conducted for studying students’ challenges with learning CT skills, but several studies have documented the challenges students face while writing programs. Most of these challenges are, however, in the context of undergraduate programming with text-based programming languages. For example, students are found to have difficulties with assembling programs and writing syntactically correct programs. Programming languages tend to have only a few components which are combined in many different ways, and learning to understand the semantic results of different combinations is considered complex. Also, understanding how to combine programs to achieve particular goals is known to be a challenge (Spohrer 1989). When students try to assemble programs by combining elements, they often get confused with syntax problems as they struggle to understand semantic ones. Another known programming challenge in the literature is students’ lack of understanding of computational processes. Many students do not understand how interpretation of traditional computer languages works, e.g., where does control flow and how do variables get updated (DuBoulay 1989).
We expect to see some of these known science and programming challenges with CTSiM as well. Since CTSiM tries to leverage the synergy between computational thinking and science education by making students computationally model a scientific phenomenon, we also anticipated situations where students’ programming challenges might be compounded by challenges with the science domain content, or vice versa, and were prepared to interleave scaffolds for the science content and the programming task.
Scaffolds in existing CT and science learning environments
The term scaffolding, as it relates to education, was introduced by Wood et al. (1976) as a metaphor describing how teachers and tutors assist learners in completing learning tasks that, without assistance, the learners would be unable to complete. Additionally, the authors list six scaffolding functions that tutors may employ: recruitment, reduction in degrees of freedom, direction maintenance, marking critical features, frustration control, and demonstration. This definition of the scaffolding process focuses on a relationship between two people and their interactions; it highlights the difficult but important task of continually diagnosing and adapting to the needs of the learner, whether that involves providing additional support, in the case that the learner is struggling, or removing support, in the case that the learner is excelling (Puntambekar and Hubscher 2005). Since this metaphor was introduced, researchers have expanded and generalized it to different aspects of computer-based learning environments. Some researchers define scaffolds as interface features (e.g., explanation construction tools; Reiser 2004). Others define scaffolds as activity sequencing within the learning environment (e.g., requiring students to answer questions before starting an invention task; Roll et al. 2012). Still others define scaffolds as supportive actions taken for the purpose of supporting learners in completing their tasks (e.g., providing hints; Azevedo and Jacobson 2008; Basu & Biswas 2016).
In this section, we discuss scaffolding mechanisms documented in the literature for helping students overcome the science and programming challenges discussed in the previous section. Reiser (2004) proposes two complementary mechanisms of scaffolding in software tools to help students with their science inquiry challenges related to sense making, process management, articulation, and reflection. He proposes (i) structuring problem-solving tasks to make them more tractable and to shape tasks for learners in ways that makes their problem-solving more productive and (ii) problematizing subject matter to provoke learners to devote resources to issues they might not otherwise address. Students’ learning tasks can be structured by providing structured work spaces to help decompose a task and organize work to help recognize important goals to pursue. Explicit structures such as prompts, agendas, or graphical organizers can help learners monitor their progress and keep track of what goals have been addressed and what aspects of the task are pending. Also, restricting the problem space by narrowing options, preselecting data, or offloading more routine parts of the task can help learners focus resources on the aspects of the task more productive for learning. The second proposed mechanism for scaffolding is to make some aspects of students’ work more “problematic” in a way that increases the utility of the problem-solving experience for learning. Rather than simplifying the task, the software leads students to encounter and grapple with important ideas or processes. This may actually add difficulty in the short term, but in a way that is productive for learning. For example, eliciting articulation or collaboration can help counter the tendency toward superficial and non-reflective work. Similarly, eliciting arguments and decisions can force students to think deeply about the content and the relations between the evidence and their arguments.
On the other hand, de Jong and van Joolingen (1998) describe different ways to support learners’ challenges with discovery learning using modeling and simulation. They suggest providing the learner with direct access to domain information and then providing support for specific discovery processes. Insufficient prior knowledge might be the cause that learners do not know which hypothesis to state, cannot make a good interpretation of data, and move to unsystematic experimentation behavior; hence, providing access to domain information comprises the first level of support. Then, students can be supported by providing them with a hypothesis menu or scratchpad, experimentation hints and strategies, tools for making predictions, and planning and monitoring tools. Decomposing and structuring the discovery process can also be useful scaffolds.
With respect to supporting learning of emergent science phenomena, agent-based modeling holds immense potential. As discussed earlier in the “Agent-based modeling can leverage students’ prior knowledge” section, it provides the means to build on students’ intuitive understandings about individual agents acting at the micro-level to grasp the mechanisms of emergence at the aggregate macro-level.
Scaffolds for programming challenges are limited and have focused on pointing out syntax errors in students’ programs or providing tools to help debug programs. Alleviating syntax problems is believed to help students focus on the semantic ones (Soloway 1993). In fact, research comparing learning in a more and a less syntactically strict language, Java and Python respectively, attribute the greater success of students in Python to be a result of reduced syntactic complexity (Mannila et al. 2006). Alleviating syntactic complexity is something we achieve in CTSiM by using a visual programming paradigm. Thus, bugs in CTSiM are always semantic errors and never the result of a typing error or a misremembered detail of the language syntax. Some research also claims that visual programming languages can make understanding the algorithmic flow of control more accessible by making complex elements of flow of control, such as loops and conditionals, more natural (Parsons and Haden 2007a, b).
While several existing computer-based learning environments include scaffolds like explanation construction tools, guiding questions, argumentation interfaces, workspaces for structuring tasks, data comparison tools, and tools for observing effects of plans made or models built, several of these scaffolds are part of the environment design and are not adaptive. As Puntambekar and Hubscher (2005) point out, such tools now described as scaffolds provide us with novel techniques to support student learning, but they neglect important features of scaffolding such as ongoing diagnosis, calibrated support, and fading. Adaptive scaffolding involves responding to individual learner challenges. In computer-based environments, it involves tracking and interpreting learner actions. For example, in Ecolab (Luckin and du Boulay 1999)—a modeling- and simulation-based environment, the scaffolding agent intervenes whenever students specify an incorrect relationship in their models and provides a progression of five hints, each more specific than the previous one, with the final hint providing the answer. Co-Lab (Duque et al. 2012), on the other hand, tracks student actions to provide feedback about both students’ solutions (the models built by students) and work processes, but is still limited to reminding students about specific actions they have not taken or should employ more frequently for model building and testing. AgentSheets (Repenning et al. 2010) is an example of one of the very few CT-based environments which include adaptive scaffolds. Students are provided an automatic assessment of the computational artifacts they build (games or science simulations). The CT patterns present in students’ artifacts are compared against desired CT patterns for the artifacts and represented in terms of what is known as the Computational Thinking Pattern graph.