Background: Ongoing debates about the structure of cognitive load theory, which traditionally distinguishes among intrinsic, extraneous, and germane cognitive load, have important implications for how cognitive load is measured in educational research. Cognitive load theorists debate the distinction between germane and intrinsic load, as well as the reliability of self-reported cognitive load measures and their ability to capture germane load. Prior critiques of cognitive load surveys may equally apply to the widely used measurement tools in computer science education.

Background: Live coding, or the process of instructors writing code in real time in front of students, is an alternative teaching method to showing students static code examples. Variations of live coding tightly coupled with more active learning approaches are common, which can make it difficult to understand the contribution of live coding alone.

Introductory programming courses can be taught in a variety of ways, including live coding, where instructors write code in real-time in front of students, or static code examples, where pre-prepared code is explained to students. While previous studies have compared live coding and static coding and their impacts on student assessment and cognitive load in large lecture environments, we present our experiences in a single lab session, highlighting student engagement differences. After presenting the same material to groups of students through a live-coding presentation and a static code presentation, we reflect on the observable differences in student engagement through an established framework of cognitive engagement. Additionally, we compare pre-surveys, post-tests, and cognitive load surveys from both groups. While our findings did not result in significant differences in student assessments, our experience highlighted differences between live and static code presentations. Live coding presentations can often take up to twice as long as static code presentations. Students may tend to ask more questions in live coding presentations, suggesting live coding provides instructors and students with more opportunities for further discussion. Live coding may also provide the instructor with additional opportunities to discuss other concepts that may not have been included in a pre-prepared presentation.

Computational thinking (CT) has been described as a set of valuable skills for tackling complex problems. To foster CT among K-12 students, different initiatives have been introduced by governmental and non-governmental entities, and numerous studies have been carried out by researchers to define and integrate CT into school curriculum. However, previous studies has shown little agreement among researchers, governmental and non-governmental sectors about a unified CT definition. These dissensions have introduced challenges in formulating a definition for CT at the K-12 level. The absence of a unified definition may increase the challenges for teachers to teach and integrate CT into school curriculum. To foster CT among K-12 students, we introduce a definition and framework for CT. We evaluated 39 articles and extracted the most common elements used in the literature to frame CT definition and describe its elements. Several studies have discussed, as well as investigated, the significance of conceptualizing and comprehending the interaction and dependency relationships among computational objects. However, our literature review discovered that little attention has been dedicated to the concept of dependency in the CT body of knowledge. Based on the literature review, we define CT as the thought process used for solving problems, and it encompasses the elements of problem decomposition, abstraction, and algorithmic thinking. We conjecture the CT definition is missing the element of dependency. In the context of CT, we define dependency as the knowledge of comprehending the interrelationships between different sections of a decomposed problem.

Programming is a complex task that requires the development of many skills including knowledge of syntax, problem decomposition, algorithm development, and debugging. Code-writing activities are commonly used to help students develop these skills, but the difficulty of writing code from a blank page can overwhelm many novices. Parsons problems offer a simpler alternative to writing code by providing scrambled code blocks that must be placed in the correct order to solve a problem. The extensive literature on Parsons problems documents numerous benefits to using them as both formative and summative assessments. These include more efficient learning, the possibility to dynamically adapt to learner needs, and more reliable grading. Despite these positive findings, further research is needed in order to draw broader inferences. Most work has been conducted at single institutions under unique conditions that are not easily replicated, and some prior studies have been inconclusive or had limitations that affected data validity. To address this, we propose a multi-institutional and multi-national study of the effectiveness of Parsons problems for novice programmers. We will focus on introductory programming courses (CS0/1/2) that use Java, Python, and C/C++ as these are the most common teaching languages. The working group will collaborate to refine the scope, methodology and research questions, and contribute to data collection and analysis.

Increasingly, languages used in computing curricula offer abstract constructs that permit list iteration by value, in addition to the traditional access by index. Given this option, this study explores the loop constructs students choose when solving a problem. We asked students from introductory programming courses to write solutions to two tasks that require iteration through array or list objects, analyzing their responses and noting coding constructs that indicate a loop-by-value strategy or a loop-by-index strategy. Consistent with previous accounts, we find that students may employ a strategy based on their experience and the required task. However, they often implement the strategy using code elements that are inconsistent with the chosen strategy, including referencing the index when a reference to the value at the location of the index is required. Some inconsistencies, such as the use of misleading variable names, do not affect program execution but often coincide with other inconsistencies that produce incorrect code. We recommend that instructors provide explicit scaffolding for the sequential introduction of iterative constructs. We note that a discussion of when each type of loop is typically used may be insufficient and suggest reinforcing habits for maintaining and checking consistency of looping strategies.

A notional machine is a pedagogic device to assist the understanding of some aspect of programs or programming. It is typically used to support explaining a programming construct, or the user-understandable semantics of a program. For example, a variable is like a box with a label, and assignment copies or moves a value into that box. This working group will capture examples of notional machines from actual pedagogical practice, as expressed in textbooks (or other teaching materials) or used in the classroom. We will interview at least 30 teachers about their experience with, and perceptions of, the use of notional machines in teaching. Using the interviews, we will work on devising and refining a form to characterise essential features of notional machines. We will also attempt to relate them to each other to describe potential learning sequences or progressions. The working group report will contain descriptions of notional machines used at different levels in education, in different countries, by many teachers. Capturing and Characterising Notional Machines Sally Fincher, Johan Jeuring, Craig S Miller Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for third-party components of this work must be honored. For all other uses, contact the owner/author(s). ITiCSE 2020,,Trondheim, Norway © 2020 Copyright held by the owner/author(s). 978-1-4503-0000-0/18/06...$15.00 https://doi.org/10.1145/1234567890 The resulting catalogue of notional machines will allow a teacher to select a machine for a particular use, permit comparison between them, and provide a starting point for further categorization and analysis of notional machines. Additionally, we will make more theoretical explorations. We will explore a variety of presentational formats, examining what is necessary and what superfluous; we will look for dimensions of comparison and will examine how notional machines are instantiated across the discipline. We argue that the creation and use of notional machines is potentially a signature pedagogy for computing [1] and that creating and using notional machines represents a certain level of pedagogic sophistication that might be an indicator of pedagogic content knowledge (PCK).

We investigate conditions in which novices make some reference errors when programming. We asked students from introductory programming courses to perform a simple code-writing task that required constructing references to objects and their attributes. By experimentally manipulating the nature of the attributes in the tasks, from identifying attributes (e.g., title or label ) to descriptive attributes (e.g., calories or texture ), the study revealed the relative frequencies with which students mistakenly omit the name of an identifying attribute while attempting to reference its value. We explain how these reference-point shifts are consistent with the use of metonymy, a form of figurative expression in human communication. Our analysis also reveals how the presentation of examples can affect the construction of the reference in the student’s solution. We discuss plausible accounts of the reference-point errors and how they may inform a model of reference construction. We suggest that reference-point errors may be the result of well-practiced habits of communication rather than misconceptions of the task or what the computer can do.

We investigated implications of transparent mechanisms in the context of an introductory object-oriented programming course using Python. Here transparent mechanisms are those that reveal how the instance object in Python relates to its instance data. We asked students to write a new method for a provided Python class in an attempt to answer two research questions: 1) to what extent do Python's transparent OO mechanisms lead to student difficulties? and 2) what are common pitfalls in OO programming using Python that instructors should address? Our methodology also presented the correct answer to the students and solicited their comments on their submission. We conducted a content analysis to classify errors in the student submissions. We find that most students had difficulty with the instance (self) object, either by omitting the parameter in the method definition, by failing to use the instance object when referencing attributes of the object, or both. Reference errors in general were more common than other errors, including misplaced returns and indentation errors. These issues may be connected to problems with parameter passing and using dot-notation, which we argue are prerequisites for OO development in Python.

One approach for helping students learn to program is the use of self-explanation assignments. In these assignments, students explain instructional materials using domain knowledge covered in the course. In this work, we describe a randomized experiment where students in an introductory programming course were given two kinds of self-explanation assignments. One randomly selected group worked on self-explanation assignments with supporting questions while the alternate group had the same self-explanation questions but no additional supporting exercises. The combined groups performed better on comparable test questions than students from the previous year, who did not use self-explanation questions. The group with supporting questions performed better than the group with no additional support. Based on our results and previous research on self explanation, we argue that embedding self-explanation questions into programming material is beneficial for students. Moreover, further gains are achieved from supporting questions that help focus their explanations.

Despite its prevalence in computing, web development is underrepresented in computing curricula and computing education research. This special issue takes a step towards improving its representation with three articles on web development education. Drawing upon diverse methods from a variety of contexts, the articles address challenges of teaching web development and common difficulties students encounter when learning particular concepts. All three articles identify web development as a promising avenue for motivating students in their study of computing.

When creating a taxonomy for information architecture, practitioners or design participants typically work with a sample of content items to form categories that allow users to successfully navigate to desired information, commands, or items. In order to examine how sample selection affects the coverage of the desired taxonomy, computer simulations were conducted that models the process of sample selection. The simulations reveal how the number of categories, the distribution of items in the taxonomy and the method of selection affect the coverage of a sample at various sizes.

Previous research comparing methods of issuing commands found that selecting a toolbar item is faster than selecting an item from two menus with either a mouse or keyboard shortcut. Over the course of 90 trials, however, the keyboard method showed the most improvement, nearing the toolbar response time. The study presented in this paper compared the response time of the keyboard method across 240 trials when items were drawn from a single versus two menus. Throughout the trials, the 1-menu condition produced selection times that were on average 600 ms to 800 ms faster than the 2-menu condition suggesting users in the 2-menu condition were not able to bypass the menu decision by chunking the 3-key sequence into one cognitive unit. Models are presented to describe performance at various stages of learning. Practical implications are that hierarchical, category-based keyboard commands do not provide a clear advantage to toolbar-based selection and that theory-based evaluation methods may need to reflect this result.

Specifying file references for hypertext links is an elementary competence that nevertheless draws upon core computational thinking concepts such as tree traversal and the distinction between relative and absolute references. In this article we explore the learning effects of different instructional strategies in the context of an introductory computing course. Results suggest that asking students to do targeted tasks, albeit supported with working examples, is not the best preparation. Instead, unstructured study of examples produces superior learning. Answering targeted conceptual questions can also yield comparably positive learning but only in qualified contexts. While perhaps unintuitive, these results are consistent with a long line of research on human cognition and learning. We discuss our results in the context of this previous research and recommend effective instructional strategies, which may apply to a broad range of computational concepts.

We study student understanding of the use of a tree structure in the context of an introductory web development course. In particular, we analyze student answers as they use a tree structure to construct file references in web pages. More fundamentally, our study initiates a bottom-up study of computational thinking by identifying the computational thinking mistakes that students make when they are learning resource referencing for web development. Our preliminary results suggest that students do not necessarily learn abstract concepts (like trees) and abstract rules of reasoning (composing relative and absolute tree paths) by just working with folders and composing file references alone.

Educators are increasingly acknowledging that practical problems in computer science demand basic competencies in experimentation and data analysis. However, little effort has been made towards explicitly identifying those empirical concepts and skills needed by computer scientists, nor in developing methods of integrating those concepts and skills into CS curricula. In this paper, we identify a core list of empirical competencies and motivate them based on established courses outside of computer science, their potential use in standard CS courses, and their application to real-world problems. Sample assignments that facilitate the integration of these competencies into the CS curriculum are also discussed.

Previous studies for menu and Web search tasks have suggested differing advice on the optimal number of selections per page. In this article, we examine this discrepancy through the use of a computational model of information navigation that simulates users navigating through a Web site. By varying the quality of the link labels in our simulations, we find that the optimal structure depends on the quality of the labels and are thus able to account for the results in the previous studies. We present additional empirical results to further validate the model and corroborate our findings. Finally we discuss our findings' implications for the information architecture of Web sites.

Empirical skills are playing an increasingly important role in the computing profession and our society. But while traditional computer science curricula are effective in teaching software design skills, little attention has been paid to developing empirical investigative skills such as forming testable hypotheses, designing experiments, critiquing their validity, collecting data, explaining results, and drawing conclusions. In this paper, we describe an initiative at Dickinson College that integrates the development of empirical skills throughout the computer science curriculum. At the introductory level, students perform experiments, analyze the results, and discuss their conclusions. In subsequent courses, they develop their skills at designing, conducting and critiquing experiments through incrementally more open-ended assignments. By their senior year, they are capable of forming hypotheses, designing and conducting experiments, and presenting conclusions based on the results.