Background: Context personalization, the practice of adapting learning materials to students’ personal interests, has been shown to increase student learning and engagement. Within computer science education, research has found that LLMs can generate high-quality contextualized introductory programming exercises. Objective: In this paper, we evaluate the capability of LLMs to generate technically correct and thematically integrated contextualized algorithm design problems. Methods: In a series of three iterative studies, we use LLMs to generate contextualized algorithm design problems from a given base problem and theme, evaluating over 500 generated problems for technical and thematic alignment. Results: We find that LLM-generated algorithm design problems exhibit significantly more issues than prior work has found for introductory programming problems. We identify issues specific to the algorithm design context and then mitigate these issues with prompt engineering techniques and model choice. With these adjustments, we produce LLM-generated contextualized algorithm design problems that are technically strong, deeply themed, and largely realistic, though realism drops with more culturally and locally specific themes. Implications: We demonstrate a viable workflow for generating contextualized algorithm design problems using LLMs, including prompt design, model selection, and identification of specific issues to review for.

Integrating literacy and computational thinking (CT) can broaden computer science education participation, especially for multilingual learners. This study examined how the Computing and AI for All (CAIforALL) Act 1 Curriculum, an ELA-integrated Scratch-based CT curriculum, impacts coding attitudes among elementary students in predominantly Latine and multilingual districts. The curriculum integrates literacy strategies into CT instruction as proposed by the National Academies of Sciences, Engineering, and Medicine (NASEM) to support multilingual learners. We conducted a cluster randomized controlled trial with 1,325 students in grades 3–5 across 23 schools in two suburban districts. The treatment group used an ELA-integrated CT curriculum for a school year while controls continued with business-as instruction. Pre- and post-surveys measured five coding attitude constructs: confidence, interest, utility, perceived coding values of social circles, and perceptions of young coders. We estimated treatment effects using a two-level hierarchical linear model, controlling for student and classroom characteristics. Findings show no statistically significant differences emerged in overall coding attitudes between groups. However, students exposed to a year of ELA-integrated CT curriculum showed significant increases in coding confidence. The curriculum did not significantly affect other attitude dimensions. Findings suggest that an ELA-integrated CT curriculum can enhance coding confidence among elementary students, demonstrating the value of early computing exposure and integrated approaches.

The ability to identify the important takeaways from a previously-seen solution and apply them in different contexts is an important problem-solving skill. However, this skill, known as analogical reasoning, is traditionally left implicit in algorithms courses. Students are expected to develop the skill naturally as they progress through the course. In this study, we aim to conduct a more thorough investigation of analogical reasoning in algorithms. We integrate explicit metacognitive scaffolds for reflection and schema development into an undergraduate algorithms course. Then, on course exams, we insert an additional task alongside select algorithm design questions, in which students are asked to describe how a previously-seen problem influenced their design. We analyzed both the previously-seen problem selected by the student and the stated similarity. Within the 142 comparisons analyzed, we find that 37% provide insight about the underlying solution structure, and these comparisons were significantly associated with higher scores on the problem. Furthermore, about one-third of the comparisons were with a problem that course staff also selected, and these comparisons were not only much more likely to be structural but were also correlated with higher performance on the question. Our results indicate that the analogical reasoning skills are closely tied to success in the algorithms course, and encourage instructors to integrate explicit demonstrations into their curriculum.

Teachers are well positioned to customize curricula to local contexts. In CS, one approach involves choosing themes relevant to students and incorporating them into the technical materials (e.g., Scratch projects, CS concept explanations). However, teachers' time constraints make curriculum customization challenging. This poster introduces Conjuror, an interactive GenAI tool to help teachers create contextually customized Scratch projects aligned with a structured curriculum while retaining teacher agency. We present Conjuror design and its pilot with two teacher cohorts, showing promising evidence for process efficiency and output quality.

Quantum Computing is typically the realm of upper-division undergraduate or graduate level university courses, taught with substantial higher-level mathematics, and taught by domain experts. More intuitive methods of teaching concepts, such as a visual representation, online game, physical card game, and hands-on activities have been developed more recently to allow K-12 and university to learn and teach such content.

Dynamic Programming (DP) is commonly regarded as one of the most difficult topics in the upper-level algorithms curriculum. The teaching of metacognitive strategies may prove effective in helping students learn to design DP algorithms. To explore both whether students learn and use these strategies on their own and the effect of guidance about using these strategies, we conducted think-aloud interviews with structured guidance at two points in a college algorithms course: once immediately after students learned the concept and once at the end of the course. We explore 1) what metacognitive strategies are commonly employed by students, 2) how effectively they help students solve problems, and 3) to what extent structured guidance about using metacognitive strategies is effective. We find that these strategies generally help students make progress in solving DP problems, but that they can mislead students as well. We also find that the adoption of these strategies is an individualized process and that structured strategy guidance is often insufficient in allowing students to solve individual DP problems, indicating the need for more extensive strategy instruction.

According to an ecological affordances perspective, any static curriculum has a set of affordances, and differences in teachers, students, and the teaching environment change how those affordances are viewed and used. Therefore, teaching is a relationship between the curriculum, the teacher, and the students. As such, it is not only possible but expected that a teacher will diverge from the details of a lesson plan to better accommodate the needs of themselves as a teacher and their students as learners.

While many recent studies have explored how large language models can transform computer science instruction from the instructor perspective, they are primarily at the college level. Thus, little is known about using large language models towards curriculum development and teacher supports outside of the college setting. Given the emphasis placed on culturally responsive teaching at the K-8 level and well-documented evidence of insensitive and inaccurate language model outputs from a cultural perspective, it is imperative to perform systematic and principled research before considering their use in this setting.

Dynamic programming (DP) is one of the most challenging topics in algorithms courses. Although there exist animation tools that assist with the understanding of DP algorithms, few existing tools are aimed at scaffolding the process of solving DP algorithm design problems. To help create a learning tool able to provide the affordances learners need when attempting DP problems, we analyzed learners' scratch paper to understand how learners approach DP problems. Based on scratch paper from 18 learners solving DP problems during a think-aloud study, we created a codebook that characterized different elements and methods used by the learners on their scratch paper. We found that learners had distinct preferences when attempting DP problems. Some learners preferred using example input with specific values to simulate ideal program executions, while some used math representations of example inputs to help derive formulas. Learners interacted with their example input in multiple ways, including filling in hand-drawn tables to organize the calculation process and dynamically interacting with the inputs by crossing, circling, or using arrows to visualize the relationships between inputs. These findings suggest potential interactions that need to be taken into consideration when designing tools to support learners in solving DP problems.

Algorithm design is a vital skill developed in most undergraduate Computer Science (CS) programs, but few research studies focus on pedagogy related to Algorithms coursework. To understand the work that has been done in the area, we present a systematic survey and characterization of existing studies in the CS Education literature related to the teaching of algorithm design at the undergraduate level. Across all papers in the ACM Digital Library, we only find 97 applicable papers. We classify these papers by topic, evaluation metric, evaluation methods, and intervention target. We present the results of these classifications alongside insights about existing knowledge, rigor, and contribution rates. We hope that this work not only provides a detailed representation of the current corpus of CS Education work related to algorithm design but also demonstrates that the body of knowledge is sparse and supports further research in the area. For future work, we intend to investigate and synthesize the conclusions reached by these papers.

The past decade has seen a growing number of culturally relevant K-8 computer science curricula. However, as teachers are the experts on their own classrooms, empowering them to customize instructional materials that draw on the cultural identities and personal experiences of their students can be a powerful strategy. Unfortunately, this process can be challenging and time-consuming.

Decomposition is a foundational computational thinking construct that is often introduced early as students are learning computer science in the elementary grades. Although decomposition is often described in early computational activities, little research exists about how to teach and assess students’ understanding of decomposition. In this mixed-methods research study, 173 third-grade students from eight elementary school classrooms in the Midwest were taught eight lessons that integrated decomposition as well as other computational thinking practices into their mathematics instruction. They completed a computational thinking assessment after the first four lessons and again after the second four lessons. Analyses included the distribution of correct decomposition item responses, confirmatory factor analysis, and item-level error analysis. Results indicate wide variability in students’ performance on the decomposition assessment items as well as in performance on items contextualized within mathematics. This study highlights the need for additional considerations about assessing computational understanding, implications for assessment within integrated contexts, and the use of paper-and-pencil tests compared to embedded assessments.

Computer science learning in primary school classrooms has expanded, necessitating effective instructional strategies for this age group. Gallery Walks are a common activity to allow peers to share their work and give feedback on peers’ work. Like other skills, providing effective feedback may require scaffolding and/or instruction for some students.

Quantum computing presents a paradigmatic shift in the field of computation, in which unintuitive properties of quantum mechanics can be harnessed to change the way we approach a wide range of problems. However, due to the mathematics and physics perspective through which quantum computing is traditionally presented, most resources are inaccessible to many undergraduate students, let alone the general public. It is thus imperative to develop resources and best-practices for quantum computing instruction accessible to students at all levels. In this paper, we describe the development and results of our Massive Open Online Course (MOOC) "Introduction to Quantum Computing for Everyone." This course presents an introduction to quantum computing with few technical prerequisites. In the first half of the course, quantum computing concepts are introduced with a unique, purely visual representation, allowing students to develop conceptual understanding without the burden of learning new mathematical notation. In the second half, students are taught the formal notation for concepts and objects already introduced, reinforcing student understanding of these concepts and providing an applicable context for the technical material. Most notably, we find that introducing the math content in the curriculum's second stage led to no drops in engagement or student performance, suggesting that our curriculum's spiral structure eased the technical burden.

Quantum computing (QC) is an emerging field at the intersection of computer science and physics. Harnessing the power of quantum mechanics, QC is expected to solve otherwise intractable problems significantly faster, including in encryption, drug development, and optimization. High-quality and accessible QC resources are needed to help students develop the critical skills and confidence to contribute to the field. However, existing programs are often aimed at college students with an advanced mathematics or physics background, shutting out potential innovators.

Researchers and practitioners have worked to bring computer science to all students. However, CS is still an inequitable field. When developing curricula, we must account for the importance of connecting the lives and identities of historically marginalized students with instructional materials. We examine the knowledge and experiences that elementary (age 9-10) students drew upon to implement an open-ended programming assignment about themselves. We coded the Scratch projects of 189 students to investigate what aspects of their lives students reference, and how they use various modalities in Scratch to create digital media products about themselves. In our data, we found that the most common spheres portrayed were identity, hobbies and leisure, and interests. When expressing their identities, students narrated their experiences, expressed consciousness about their skills, connected to the user via their interests, and sometimes discussed equity. Additionally, our findings add to previous literature on Scratch as an effective platform for digital media production. In particular, we found that students used dialogue, images, sound, and the title to represent their spheres of influence through programming multimedia and interactive projects. This work has implications for the development of curricula and teaching guides for upper elementary students courses on computational thinking. Spheres of influence could inform researchers on the most influential aspects of students life in a specific context, providing elements for creating culturally relevant and interest-based materials and lessons.

The worldwide push for computing education at younger ages requires that teachers are prepared to deliver instruction that supports all learners. Other discipline-based education research fields offer a wealth of instructional scaffolds worthy of exploration in computing. One such scaffold drawn from math education is diagramming. While diagrams are frequently employed in university computing, little is known about its applications in K-8 (ages 6-14) computing.

Ensuring that computer science curricula connect to learners' home culture, interests, and lived experiences is one approach to making the field more equitable. A central feature of the Scratch Encore Curriculum is to provide many opportunities for learners to plan and implement open-ended programming projects that invite them to draw on their prior knowledge, experiences, and cultural resources. To date, relatively little research has been done to analyze how learners respond to such curricular invitations, specifically with respect to what aspects of themselves and their interests they choose to express in their resulting projects.

Open-ended tasks can be both beneficial and challenging to students learning to program. Such tasks allow students to be more creative and feel ownership over their work, but some students struggle with unstructured tasks and, without proper scaffolds, this can lead to negative learning experiences. Scratch is a widely used coding platform to teach computer science in classrooms and is designed to support learner creativity and expression. With its open-ended nature, Scratch can be used in various ways in the classroom to meet the needs of schools and districts. One challenge of using Scratch in classrooms is supporting learners in exploring their interests and fostering creativity while still meeting the instructional goals of a lesson and ensuring all students are engaged with, and understand, focal concepts and practices.

In 2020, the world confronted an unprecedented event affecting education globally: COVID-19. Events that disrupt education are not new; Homelessness or trauma negatively impact education at an individual level, whereas war stops education completely. This event is unique in that it caused the cessation of in-person instruction for all but with a rapid transition to remote instruction.

Background and Context. With increasing efforts to bring computing education opportunities into elementary schools, there is a growing need for assessments, with arguments for validity, to support research evaluation at these grade levels. After successfully piloting a 10-question computational thinking assessment (Assessment of Computing for Elementary Students – ACES) for 4th graders in Spring 2020, we used our analyses of item difficulty and discrimination to iterate on the assessment. Objectives. To increase the number of potential items for ACES, we created isomorphic versions of existing questions. The nature of the changes varied from incidental changes that we did not believe would impact student performance to more radical changes that seemed likely to influence question difficulty. We sought to understand the impact of these changes on student performance. Method. Using these isomorphic questions, we created two versions of our assessment and piloted them in Spring 2021 with 235 upper-elementary (4th grade) students. We analyzed the reliability of the assessments using Cronbach’s alpha. We used Chi-squared tests to analyze questions that were identical across the two assessments to form a baseline of comparison and then ran Chi-Squared and Kruskal-Wallis H tests to analyze the differences between the isomorphic copies of the questions. Findings. Both assessment versions demonstrated good reliability, with identical Cronbach’s alphas of 0.868. We found statistically similar performance on the identical questions between our two groups of students, allowing us to compare their performance on the isomorphic questions. Students performed differently on the isomorphic questions, indicating the changes to the questions had a differential impact on student performance. Implications. This paper builds on existing work by presenting methods for creating isomorphic questions. We provide valuable lessons learned, both on those methods and on the impact of specific types of changes on student performance.

Given the increasing interest and need to teach students computer science in formal education settings, it is imperative to understand how to do so effectively and equitably. An important step of learning to program is being able to define the objective of a program and then plan out how to implement a program to produce the desired outcome. This step is particularly important in younger learners who may have little experience with programming or trying to create their own technological artifacts. In this paper, we explore how to scaffold young programmers in planning their open-ended programs as part of an intermediate Scratch curriculum for middle grade students. We analyze 203 paper and virtual planning documents from 103 5th-8th grade students. Our results reveal that the students often completed a majority of the document, which was consistent across grade levels. However, we found differences in student completion based on teacher and between physical and virtual documents. This work advances our understanding of how to support novice, young programmers in planning programs.

There is an increasing need for knowledgeable K-12 computer science (CS) teachers. It is necessary to inform teachers how to debug and help their students debug programs. Research has shown that debugging is difficult for novices because the process requires different skills from creating programs and instructing students how to debug can help them acquire these skills. To this end, we developed a CS professional development for middle grade teachers (grades 5th-8th/ages 10-13) that includes lessons on debugging. The teachers completed debugging activities that involved finding bugs in Scratch programs and explaining how they would help their students in debugging. We qualitatively analyzed their responses and found that teachers successfully identified the problem but they struggled to locate it in the code. In considering how they would help students who had such a bug, the teachers often focused on helping the student find a solution for the bug rather than on identifying the problem or its source. Finally, teachers' ability to identify bugs and the pedagogical strategies to engage students in this process differed based on CS teaching experience and prior CS knowledge. This work contributes to our understanding of teachers' debugging abilities and advances our knowledge on how to support teachers in teaching their students how to debug their programs.

There is a need for more K-12 computer science (CS) teachers. The need to scale teacher professional development (PD) points the CS education community towards virtual learning, and prior work shows that in-person PD with a diffuse schedule is more successful than condensed schedules. There is currently little research about virtual K-12 CS PD with a diffuse schedule. The pandemic served as a forced opportunity to explore the design and implementation of a diffuse-scheduled virtual PD for two small, equally-sized cohorts of middle school (grades 5-8) teachers; one from a metropolitan school district and another from across the United States.

With the global movement to incorporate computer science instruction into elementary education, learners are being introduced to computer science and computational thinking (CS/CT) ideas at increasingly younger ages. At these early ages, young learners are developing cognitive abilities foundational to their education. While other discipline-based education fields, such as math, science, and reading, have long studied the role of cognitive abilities, such as short-term working memory and long-term retrieval, in their respective fields, similar research in computer science education is relatively sparse.

Worldwide, national initiatives have led to many school districts implementing computing curricula at the primary level. At that age, students are learning the foundational skills of reading and math. It is important to understand how computing can influence the development of these skills. While some argue that learning computing sharpens problem-solving skills that are applicable to other subjects, evidence supporting this belief is thin.

Given the importance of broadening participation in the field of computing, goals of supporting personal expression and developing a sense of belonging must live alongside the goals of conceptual knowledge and developing disciplinary expertise. Integrating opportunities for students to be creative in how they enact computing ideas plays an important role when designing curricula. We examine how student creativity, as expressed through theme and the use of costumes, backdrops, and narrative in Scratch projects, is affected by using a themed starter project. Starter projects are Scratch projects that include a set of sprites and backdrops aligned to a theme (e.g. baseball), but no code. Using within-group and between-group comparisons, we establish a baseline of what students do when they are given a starter project and explore how their projects differ in the absence of a starter project. This work contributes to our understanding of the impacts of structured elements within open-ended learning tasks and how we can design computer science learning experiences for students that promote opportunities for self-expression while engaging them in computing.

As reliance on technology increases in practically every aspect of life, all students deserve the opportunity to learn to think computationally from early in their educational experience. To support the kinds of computer science curriculum and instruction that makes this possible, there is an urgent need to develop and validate computational thinking (CT) assessments for elementary-aged students. We developed the Assessment of Computing for Elementary Students (ACES) to measure the CT concepts of loops and sequences for students in grades 3-5. The ACES includes block-based coding questions as well as non-programming, Bebras-style questions. We conducted cognitive interviews to understand student perspectives while taking the ACES. We piloted the assessment with 57 4th grade students who had completed a CT curriculum. Preliminary analyses indicate acceptable reliability and appropriate difficulty and discrimination among assessment items. The significance of this paper is to present a new CT measure for upper elementary students and to share its intentional development process.

With the growth of Computer Science (CS) and Computational Thinking (CT) instruction in the primary/elementary domain, it is important that such instruction supports diverse learners. Four categories of students -- students in poverty, multi-lingual students, students with disabilities, and students who have below-grade-level proficiency in reading and math, may face academic challenges that can hinder their learning in CS/CT curricula. However, little is known about how to support these students in CS/CT instruction, especially at this young age. TIPP&SEE, a meta-cognitive strategy that scaffolds learning by proceduralizing engagement through example code, may offer some support. A quasi-experimental study revealed that the gaps between students with and without academic challenges narrowed when using the TIPP&SEE strategy, indicating its promise in providing equitable learning opportunities in CS/CT.

The computer science (CS) education field is exploring several instructional strategies for teaching CS to children in elementary school. Strong arguments have been made for integration--- constructing activities that not only teach CS, but use the CS to support learning in a core subject. Integrating CS materials into a specific curriculum is a non-trivial task that may unfairly burden elementary teachers, who are often generalists. Successful development and classroom implementation of integrated materials relies on many decisions about what, when, and how much subject matter to cover in relation to the main curriculum.

As computer science instruction gets offered to more young learners, transitioning from elective to requirement, it is important to explore the relationship between pedagogical approach and student behavior. While different pedagogical approaches have particular motivations and intended goals, little is known about to what degree they satisfy those goals.

Quantum computing is poised to revolutionize some critical intractable computing problems; but to fully take advantage of this computation, computer scientists will need to learn to program in a new way, with new constraints. The challenge in developing a quantum computing curriculum for younger learners is that two dominant approaches, teaching via the underlying quantum physical phenomenon or the mathematical operations that emerge from those phenomenon, require extensive technical knowledge. Our goal is to extract some of the essential insights in the principles of quantum computing and present them in contexts that a broad audience can understand.

With the rise of Computational Thinking (CT) instruction at the elementary level, it is imperative for elementary computing instruction to support a variety of learners. TIPP&SEE is a meta-cognitive learning strategy that scaffolds student learning when learning from example code. Results from a previous study show statistically-significant performance differences favoring students using the TIPP&SEE strategy on a written assessment. In this work, our goal is gain insight as to it why such dramatic learning differences may have occurred. We analyze the students' computational artifacts and TIPP&SEE worksheets. Artifact analysis reveals that students in the TIPP&SEE group are more thorough in their work, completing more elements of the required tasks. In addition, they build open-ended projects with longer scripts that utilize more learned blocks. Worksheet analysis shows that students were highly accurate on some types of questions but largely skipped others. Despite these positive behaviors, there was little statistical correlation between student worksheet correctness, project completion, and written assessment performance. Therefore, while students in the TIPP&SEE group performed actions we believe lead to more success, no individual actions directly explain the results. Like other meta-cognitive strategies, the value of TIPP&SEE may lie in cognitive processes not directly observable, and may vary based upon individual student differences.

Compiling high-level quantum programs to machines that are size constrained (i.e. limited number of quantum bits) and time constrained (i.e. limited number of quantum operations) is challenging. In this paper, we present SQUARE (Strategic QUantum Ancilla REuse), a compilation infrastructure that tackles allocation and reclamation of scratch qubits (called ancilla) in modular quantum programs. At its core, SQUARE strategically performs uncomputation to create opportunities for qubit reuse.Current Noisy Intermediate-Scale Quantum (NISQ) computers and forward-looking Fault-Tolerant (FT) quantum computers have fundamentally different constraints such as data locality, instruction parallelism, and communication overhead. Our heuristic-based ancilla-reuse algorithm balances these considerations and fits computations into resource-constrained NISQ or FT quantum machines, throttling parallelism when necessary. To precisely capture the workload of a program, we propose an improved metric, the “active quantum volume,” and use this metric to evaluate the effectiveness of our algorithm. Our results show that SQUARE improves the average success rate of NISQ applications by 1. 47X. Surprisingly, the additional gates for uncomputation create ancilla with better locality, and result in substantially fewer swap gates and less gate noise overall. SQUARE also achieves an average reduction of 1. 5X (and up to 9. 6X) in active quantum volume for FT machines.

The computer science community has struggled to assess student learning via Scratch programming at the primary school level (ages 7-12). Prior work has relied most heavily on artifact (student code/projects) analysis, with some attempts at one-on-one interviews and written assessments. In this paper, we explore the relationship between artifact analysis and written assessments. Through this study of a large-scale introductory computing implementation, we found that for students who had code in their projects, student performance on specific questions on the written assessments is only very weakly correlated to specific attributes of final projects typically used in artifact analysis as well as attributes we use to define candidate code (r < 0.2, p < 0.05). In particular, the correlation is not nearly strong enough to serve as a proxy for understanding.

Until recently, computer science (CS) has been predominantly taught at upper-secondary or tertiary levels. Lately, however, CS curricula have been introduced into school systems from the very first year of school. In this paper, we undertake a participatory research approach, using focus group discussions between a group of experts in the field of evaluation and assessment at the primary level (K-5). The group considered the evaluation and assessment measures they have used, what their current needs are and how the CS education community can move towards meeting those needs. We present the discussion results as a position paper, situated in the context of broader education research. The experts identified three key priorities for the education research community: creating a universal taxonomy of assessment in the primary grades (K-5), creating measurements of student progression and growth over time, and creating culturally relevant evaluations and assessments. Through identifying key priorities, this work provides direction for urgently needed resource development and research directions for K-5 evaluation and assessment.

As quantum computation (QC) comes closer to reality, questions arise as to what elements to teach, how to teach it, and to what depth. QC instruction typically depends heavily on advanced math and/or physics. Our interdisciplinary science / computer science / education team co-created quantum computing (QC) learning trajectories (LT), zines, and activities, for young learners. We present the LT's (Superposition, Quantum State, Entanglement, Measurement, and Reversibility) and the iterative process that created them.

With many school districts nationwide integrating Computer Science (CS) and Computational Thinking (CT) instruction at the K-8 level, it is crucial researchers closely inspect the relationship between program expression and student understandings. In this study, we propose and report on our use of Scratch Charades, a game in which students act out Scratch scripts while others build them. The purpose of Scratch Charades is to familiarize students with scripts and blocks without the cognitive overhead of the complex user interface. However, in this study, we also used it to elicit student understandings about Scratch blocks and scripts to design mnemonics to help students debug their code. We propose two building and/or debugging strategies based on our observations.

While several introductory computer science curricula exist for children in K-8, there are few options that go beyond sequence, loops, and basic conditionals. The goal of this project is to not only fill this gap with a high-quality curriculum supported by complete instructional materials, but to also do so with an equity-balanced curriculum. That is, a curriculum that values advancing equity equally with student learning outcomes. In this paper, we introduce barriers to equity in public school classrooms, pedagogical approaches to culturally-relevant curricula, and how our Scratch Encore curriculum is designed to support equity-balanced learning. Finally, we present results of our pilot year, including early evidence of students taking advantage of the culturally-relevant design aspects.

The CS community has struggled to assess student learning at the K-8 level, with techniques ranging from one-on-one interviews to written assessments. While scalable, automated techniques exist for analyzing student code, a scalable method for assessing student comprehension of their own code has remained elusive. This study is a first step in bridging the gap between the knowledge gained from interviews and the time efficiency and scalability of written assessments and automated analysis. The goal of this study is to understand how student answers on various types of questions differ depending on whether they are being asked about their own code or generic code. We find that while there were no statistically-significant differences in overall scores, questions about generic and personalized code of comparable complexity are far from equivalent. Our qualitative analyses revealed interesting patterns in student responses, inviting further research into this assessment technique. In particular, students answered differently from students with generic code when presented with individual blocks from their code taken out of context and placed into different code snippets, and students answered in a way that demonstrates a functional, instead of structural, understanding on Explain in Plain English (EiPE) questions.

With the rise of Computational Thinking (CT) instruction at the elementary level, it is imperative that elementary computing instruction support a variety of learners. A popular pedagogical approach for this age group is Use-->Modify-->Create, which introduces a concept through a more scaffolded, guided instruction before culminating in a more open-ended project for student engagement. Yet, there is little research on student learning during the Use-->Modify step, nor strategies to promote learning in this step. This paper introduces TIPP&SEE, a metacognitive learning strategy that further scaffolds student learning during this step. Results from an experimental study show statistically-significant performance gains from students using the TIPP&SEE strategy on nearly all assessment questions of moderate and hard difficulty, suggesting its potential as an effective CS/CT learning strategy.

As many school districts nationwide continue to incorporate Computer Science (CS) and Computational Thinking (CT) instruction at the K-8 level, it is crucial that we understand the factors and skills, such as reading and math proficiency, that contribute to the success of younger learners in a computing curriculum and are typically developed at this age. Yet, little is known about the relationship between reading and math proficiency, and the learning of key CS concepts at the elementary level. This study focused on 4th-grade students (ages 9-10) who were taught events, sequence, and repetition through an adaptation of the Creative Computing Curriculum. While all students benefited from access to such a curriculum, there were statistically-significant differences in learning outcomes, especially between students whose reading and math proficiency are below grade-level, and students whose proficiency are at or above grade-level. This performance gap suggests the need for curricular improvement and learning strategies that are CS specific for students who struggle with reading and math.

As part of the national Computer Science for All initiative, there is a growing presence of computer science (CS) in K-8 classrooms. This poster presents findings from a survey of 130 K-8 teachers from Chicago Public Schools (CPS) about the state of computer science in their schools and their experiences teaching it. Results from the survey highlight the plurality of ways CS is being implemented in the classroom. The survey also reveals challenges instructors face in teaching CS. Finally, the survey reports on teachers' own experiences in the classroom, finding that teachers enjoy teaching CS and think their students also enjoy CS.

In response to the growing call to bring the powerful ideas of computer science to all learners, education decision makers, including teachers and administrators, are tasked with making consequential decisions on what curricula to use. Often, these decision makers have not been trained in computer science and are unfamiliar with the concepts taught and tools used. This is especially true in K–12 contexts where computer science expertise is less prevalent. To aid in the decision-making process around computing curricula, this article introduces the TEC Rubric. The TEC Rubric is composed of three main categories: Teacher Accessibility, Equity, and Content designed to support educational decision makers and designers when it comes to computing instruction. Along with presenting the full rubric and the process used in its creation, this article describes two examples of the rubric in action. First, the TEC Rubric is used to evaluate two widespread computer science curricula to demonstrate its evaluative capacity highlighting differences between the two curricula. Second, we show how the TEC Rubric can be used to help inform the design of new K–12 computing curricula. Overall, the TEC Rubric is designed to serve as a useful resource in the ongoing quest to bring effective, equitable, and engaging computing instruction into schools around the world.

Participatory design is an essential design strategy for creating artifacts and experiences that reflect the voices of the population being designed for and with. The participatory design process can serve not only to research resulting artifacts but also as an empowering activity for those who participate. This paper explores how participatory design can serve as a context for young participants to enact and voice their emerging identities and reveals how different participatory design activities have unique affordances for supporting this identity enactment. Focusing on a group of 12 and 13-year-old African American girls, this paper presents a case study showing how participatory design activities served as venues for the girls to reflect characteristics of their current identities, project future identities, and apply aspects of their identities to shape materials for others. In doing so, we contribute a case study showing how participatory design allows participants to enact their identities, helping researchers gain insight into characteristics of those they are designing with and for. This paper advances our understanding of participatory design as a design approach for youth, especially as it relates to issues of broadening participation, identity, and equity.

The underrepresentation of women and minorities in the field of computer science is well documented. Due to this lack of representation, efforts to broaden participation in computing abound. One manner with which to do this is through the development of culturally relevant curricula. Education literature encourages the use of culturally relevant techniques and topics to teach school content through the knowledge of diverse groups as well as teach about culturally diverse populations. In addition, partnering with the students who will learn with the curriculum is encouraged in order to co-develop ideas and learn more about students' interests and experiences. This poster describes the outcomes from a series of participatory design sessions with a diverse group of stakeholders (students, teachers, parents, and administrators) to design an intermediate computing curriculum for 5th - 7th grade students. Specifically, we examine the topics developed by the participants that are being utilized as themes for curricular units. Preliminary analysis shows that participants of all ages brainstormed and utilized themes related to both cultural heritage and contemporary culture, but more focus was placed on youth culture and pop culture topics. The poster will describe the design methods used during the participatory design sessions as well as the themes developed and an overall analysis of the categories from which the themes are drawn.

Curriculum development is dependent on the following question: What are the learning goals for a specific topic, and what are reasonable ways to organize and order those goals? Learning trajectories (LTs) for computational thinking (CT) topics will help to guide emerging curriculum development efforts for computer science in elementary school. This study describes the development of an LT for Debugging. We conducted a rigorous analysis of scholarly research on K-8 computer science education to extract what concepts in debugging students should and are capable of learning. The concepts were organized into the LT presented within. In this paper, we describe the three dimensions of debugging that emerged during the creation of the trajectory: (1) strategies for finding and fixing errors, (2) types of errors, and (3) the role of errors in problem solving. In doing so, we go beyond identification of specific debugging strategies to further articulate knowledge that would help students understand when to use those techniques and why they are successful. Finally, we illustrate how the Debugging LT has guided our efforts to develop an integrated mathematics and CT curriculum for grades 3-5.

Major metropolitan school districts around the United States are implementing computer science in elementary school classrooms as part of the CS for All (CS4All) initiative. Little is known, however, about the success of such a large-scale rollout, especially in terms of equity. In this study we analyze the performance of 4th grade classrooms completing three modules of an introductory computational thinking curriculum, looking at not only overall results but also the variance in performance between high-, mid-, and low-performing schools (as identified by their school report cards). We find that all classrooms are benefiting from the computational thinking (CT) curriculum, making great strides in providing equitable access to CT education. However, statistically-significant differences in performance are present, especially between the high- and low-performing schools, showing that there is still room for improvement in developing strategies and curricula for struggling learners.

A new wave of collaborative robots designed to work alongside humans is bringing the automation historically seen in large-scale industrial settings to new, diverse contexts. However, the ability to program these machines often requires years of training, making them inaccessible or impractical for many. This paper rethinks what robot programming interfaces could be in order to make them accessible and intuitive for adult novice programmers. We created a block-based interface for programming a one-armed industrial robot and conducted a study with 67 adult novices comparing it to two programming approaches in widespread use in industry. The results show participants using the block-based interface successfully implemented robot programs faster with no loss in accuracy while reporting higher scores for usability, learnability, and overall satisfaction. The contribution of this work is showing the potential for using block-based programming to make powerful technologies accessible to a wider audience.

As new initiatives in computational thinking and computer science (CS/CT) are being developed and deployed, it is important to identify and understand the key concepts that are essential for student learning. In this study, we present the phases of construction of a learning trajectory (LT) for Decomposition in the context of CS/CT in K-8 education. From an extensive literature review, 63 learning goals representative of decomposition understanding and practices were identified and synthesized into 13 consensus goals. The focus of this paper is how relationships between these consensus goals were identified and used to place the goals into a learning trajectory. We discuss the theories and frameworks that guided the trajectory's construction as well as the methodology and justifications used to draw pathways through the trajectory in each phase. Finally, we discuss potential uses for the trajectory and suggest further explorations for decomposition in CS/CT.

Visual block-based programming environments (VBBPEs) such as Scratch and Alice are increasingly being used in introductory computer science lessons across elementary school grades. These environments, and the curricula that accompany them, are designed to be developmentally-appropriate and engaging for younger learners but may introduce challenges for future computer science educators. Using the final projects of 4th, 5th, and 6th grade students who completed an introductory curriculum using a VBBPE, this paper focuses on patterns that show success within the context of VBBPEs but could pose potential challenges for teachers of follow-up computer science instruction. This paper focuses on three specific strategies observed in learners' projects: (1) wait blocks being used to manage program execution, (2) the use of event-based programming strategies to produce parallel outcomes, and (3) the coupling of taught concepts to curricular presentation. For each of these outcomes, we present data on how the course materials supported them, what learners achieved while enacting them, and the implications the strategy poses for future educators. We then discuss possible design and pedagogical responses. The contribution of this work is that it identifies early computer science learning strategies, contextualizes them within developmentally-appropriate environments, and discusses their implications with respect to future pedagogy. This paper advances our understanding of the role of VBBPEs in introductory computing and their place within the larger K-12 computer science trajectory.

Quantum computers have recently made great strides and are on a long-term path towards useful fault-tolerant computation. A dominant overhead in fault-tolerant quantum computation is the production of high-fidelity encoded qubits, called magic states, which enable reliable error-corrected computation. We present the first detailed designs of hardware functional units that implement space-time optimized magic-state factories for surface code error-corrected machines. Interactions among distant qubits require surface code braids (physical pathways on chip) which must be routed. Magic-state factories are circuits comprised of a complex set of braids that is more difficult to route than quantum circuits considered in previous work [1]. This paper explores the impact of scheduling techniques, such as gate reordering and qubit renaming, and we propose two novel mapping techniques: braid repulsion and dipole moment braid rotation. We combine these techniques with graph partitioning and community detection algorithms, and further introduce a stitching algorithm for mapping subgraphs onto a physical machine. Our results show a factor of 5.64 reduction in space-time volume compared to the best-known previous designs for magic-state factories.

Many robotic tasks in small manufacturing sites are quite simple. For example, a pick and place task requires only a few common commands. Unfortunately, the standard languages and programming environments for industrial robots are complex, making even these simple tasks nearly impossible for novices. To enable novices to program simple tasks we created a block-based programming language and environment focused on usability, learnability, and understandability and embedded its programming environment in a state-of-the-art robot simulator. By using this high-fidelity prototype over the course of a year in a case study, a user study, and for countless demonstrations we have gained many concrete insights. In this paper we discuss the details of the language, the design of its programming environment, and concrete insights gained via longitudinal usage.

This paper reports on the communication patterns of two students in two settings: the elementary school classroom and the computer lab. One child was diagnosed with autism and the other was neurotypical. These students participated in a computer science curriculum designed for upper elementary school children (grades 4-5; ages 9-10), featuring block-based coding. The computer science instruction occurred in an inclusive general education setting. Analysis of video data revealed the child with autism communicated more (in terms of both total time speaking and interactions initiated) in the computer lab than was observed in the traditional classroom setting. Opposite trends were observed for the neurotypical child.

Computing curricula are being developed for elementary school classrooms, yet research evidence is scant for learning trajectories that drive curricular decisions about what topics should be addressed at each grade level, at what depth, and in what order. This study presents learning trajectories based on an in-depth review of over 100 scholarly articles in computer science education research. We present three levels of results. First, we present the characteristics of the 600+ learning goals and their research context that affected the learning trajectory creation process. Second, we describe our first three learning trajectories (Sequence, Repetition, and Conditionals), and the relationship between the learning goals and the resulting trajectories. Finally, we discuss the ways in which assumptions about the context (mathematics) and language (e.g., Scratch) directly influenced the trajectories.

There are various applications and operations in virtualized environments that rely on memory page stability to achieve satisfactory performance. These applications include VM live migration and memory deduplication. Unfortunately, there is a large gap between existing prediction mechanisms and actual behavior. This is the gap we hope to narrow. We make the following contributions: (1) We characterize the behavior of memory pages based on the page flags available through the linux kernel's proc file system. (2) We propose a prediction framework that can be used to predict memory pages that are highly likely to be relatively stable. (3) We study two applications that may benefit from the memory characterization and the proposed prediction framework: memory deduplication and VM live migration.

Quantum computing (QC) is at the cusp of a revolution. Machines with 100 quantum bits (qubits) are anticipated to be operational by 2020 [30, 73], and several-hundred-qubit machines are around the corner. Machines of this scale have the capacity to demonstrate quantum supremacy, the tipping point where QC is faster than the fastest classical alternative for a particular problem. Because error correction techniques will be central to QC and will be the most expensive component of quantum computation, choosing the lowest-overhead error correction scheme is critical to overall QC success. This paper evaluates two established quantum error correction codes---planar and double-defect surface codes---using a set of compilation, scheduling and network simulation tools. In considering scalable methods for optimizing both codes, we do so in the context of a full microarchitectural and compiler analysis. Contrary to previous predictions, we find that the simpler planar codes are sometimes more favorable for implementation on superconducting quantum computers, especially under conditions of high communication congestion.

As more elementary schools commit to integrating computer science instruction into their curricula, they seek guidance on what concepts are appropriate for students at different grade levels. Currently, little is known about how best to sequence computer science learning across elementary grades. In this paper, we present an analysis of 123 students' (age 9-12, grades 4-6) activities in a curriculum implemented in a visual block-based programming language. The goal of this work is to better understand the developmental appropriateness of foundational computer science ideas. All 4th, 5th, and 6th grade students in a single school completed the first module of a curriculum during the same school year with the same instructor. We analyzed each task students attempted and found that for simple concepts, there was little difference in performance between grade levels. However, differences were found for more complex topics, such as whether they completed initialization tasks and the way in which they solved 2-d navigation tasks. A closer look revealed that students understood the basic concepts, but were challenged by deeper applications of the basic concepts and influenced by non-computer science skills. This work serves as an empirically grounded investigation of elementary computer science learning and contributes to our understanding of computer science learning trajectories and concept sequencing in the late elementary grades.

We developed the Draw-A-Computer-Scientist-Test (DACST) to better understand elementary school students' conceptions of computer scientists and the nature of their work. By understanding how young children perceive computer scientists, we can broaden their ideas about the activities and images of computer scientists. We administered the DACST to 87 fourth-grade students (ages 8-9) as a pre- and post-assessment to a computer science curriculum. All students attended the same school and were taught by the same female teacher. Before the curriculum, we found that students most often drew male computer scientists working alone, and featured actions that were connected to technology in general (e.g., typing, printing), but not specific to computer science. After the curriculum, more female students drew female computer scientists than before, and the featured actions were more specific to computer science (e.g., programming a game). We also share insights about the classroom-learning environment that may have contributed to changes in students' understanding of computer scientists and their work.

Research on appropriate topics and goals for computer science (CS) education in elementary and middle school has been ongoing for decades, but the recent movement toward CS for all requires the research community to gain a better understanding of what is most important to teach, to whom, and in what order. We conducted a literature review with specific attention to cataloging computer science learning goals that experts theorize are important to teach as well as learning goals that have been explored and researched with students in K-8. By mapping the former onto the latter, we discovered six categories of goals that are theorized as important but, according to our review, are yet to be researched with K-8 students. We discuss the potential implications of these gaps for future research.

In this paper, we present an analysis of 123 students' (aged 9-12) digital stories created in a visual block-based programming language across three grade levels (grades 4-6). These students were all involved in the same introductory computer science curriculum. Participating students attended the same school and received computer science instruction from the same teacher within the context of the academic day. We analyzed each project for the extent of user-centered design that the student programmed. Specifically, we identified two components of user-centered design: 1) the programmed control choices students used, and 2) if/how they communicated those mechanisms of control to the user. Our work indicates that students in fifth and sixth grade (aged 10-12) used higher diversity of event blocks and coordinated action across multiple sprites at a higher rate compared to fourth grade students (aged 9-10). In contrast, fourth grade students tended to create more simplistic programs, rarely coordinating actions across multiple sprites. This work suggests that the construct of user-centered design within visual block-based programming languages is more complex than previously indicated. Additionally, explicit instruction about user-centered design is necessary, but may be more effective when a student reaches the age of 10 or 11 years old.

Emerging resistive memory technologies, such as PCRAM and ReRAM, have been proposed as promising replacements for DRAM-based main memory, due to their better scalability, low standby power, and non-volatility. However, limited write endurance is a major drawback for such resistive memory technologies. Wear leveling (balancing the distribution of writes) and wear limiting (reducing the number of writes) have been proposed to mitigate this disadvantage, but both techniques only manage a fixed budget of writes to a memory system rather than increase the number available. In this paper, we propose a new type of wear limiting technique, Mellow Writes, which reduces the wearout of individual writes rather than reducing the number of writes. Mellow Writes is based on the fact that slow writes performed with lower dissipated power can lead to longer endurance (and therefore longer lifetimes). For non-volatile memories, an N1to N3times endurance can be achieved if the write operation is slowed down by N times. We present three microarchitectural mechanisms (BankAware Mellow Writes, Eager Mellow Writes, and Wear Quota) that selectively perform slow writes to increase memory lifetime while minimizing performance impact. Assuming a factor N2advantage in cell endurance for a factor N slower write, our best Mellow Writes mechanism can achieve 2.58× lifetime and 1.06× performance of the baseline system. In addition, its performance is almost the same as a system aggressively optimized for performance (at the expense of endurance). Finally, Wear Quota guarantees a minimal lifetime (e.g., 8 years) by forcing more slow writes in presence of heavy workloads. We also perform sensitivity analysis on the endurance advantage factor for slow writes, from N1to N3, and find that our technique is still useful for factors as low as N1.

With the growing movement to use visual block-based languages (VBBLs) in elementary and middle school classrooms, questions arise about the learning outcomes of such activities. While some schools are content to use VBBLs to spark interest and motivation for the future pursuit of computing, others are asking, "Does this early exposure produce knowledge that transfers to traditional text-based languages (TBLs)?" If transfer is a goal, then a corollary is, "How do we design the transition to maximize the transfer?" This paper focuses on initialization of state and variables, exploring the differences between Scratch and two TBLs: C and Java. Based on observations of 9-12 year old students in a VBBL curriculum, we identify four "pieces of knowledge" that are critical for C and Java but are not nearly as obvious in Scratch, including whether, when, and how to perform initialization. We conclude with suggestions for instruction and development environment that may improve transfer.

As computer science moves from an outreach activity to a normal classroom activity in the multi-subject, mainstream elementary school classroom, curricula need to be examined to ensure they are meeting the needs of diverse students. In this paper, we present how Universal Design for Learning (UDL) was used to develop and refine a programming environment and curriculum for upper-elementary school classrooms (students aged 9-12). We then present our accommodations and modifications to emphasize the ways our development environment and/or curriculum enabled such uses. Ensuring introductory computer science experiences are equitable and accessible for a wide range of student learners may broaden the diversity of individuals who perceive themselves as capable of pursuing computer science in the future.

In this paper, we present our analysis of 92 fourth graders' digital story projects completed in LaPlaya, a Scratch-like programming environment. Projects were analyzed for the way that students programmed the start of the story, and if the program integrated user-centered design by providing instruction to the user on how to interact with the digital story. We found that fourth grade students rarely used user-centered design while creating digital stories in our block-based programming environment. Without explicit instruction, the demands of learning programming and simultaneously programming for an abstract user may be too cognitively demanding for the average fourth grader.

Quantum computing (QC) offers huge promise to accelerate a range of computationally intensive benchmarks. Quantum computing is limited, however, by the challenges of decoherence: i.e., a quantum state can only be maintained for short windows of time before it decoheres. While quantum error correction codes can protect against decoherence, fast execution time is the best defense against decoherence, so efficient architectures and effective scheduling algorithms are necessary. This paper proposes the Multi-SIMD QC architecture and then proposes and evaluates effective schedulers to map benchmark descriptions onto Multi-SIMD architectures. The Multi-SIMD model consists of a small number of SIMD regions, each of which may support operations on up to thousands of qubits per cycle.

Visual block-based programming environments allow elementary school students to create their own programs in ways that are more accessible than in textual programming environments. These environments help students write code by removing syntax errors and reducing typing. Students create code by dragging, dropping, and snapping constructs together (e.g. blocks) that are organized by lists, colors, shape, images, etc. However, programming in visual block-based environments is not always simple; in fact, it can become complex quickly. In addition to elements that create code, the visual aspects of these environments provide readers information about what happens, when, and how. Here, we focus on how students used visual cues when reading programs in our block-based programming environment, LaPlaya, a variant of Scratch. Specifically we identified the visual cues students noticed and acted upon. These included not only those that were intended by designers (perceptible affordances), but also those that were not intended by designers (false affordances). Through a detailed content analysis of 13 focus groups with fourth graders we created an initial taxonomy of visual cues in our programming environment and explored how students used these cues to make predictions about provided code, and the types of affordances such cues offered students.

As awareness of computer science education grows in the general public, it is important to showcase computer science education as accessible for all grades K-12 and beyond. As panelists present the projects and research they've been conducting, we will highlight three overarching topics:

This workshop introduces our elementary school programming curriculum, KELP-CS, and the corresponding programming environment LaPlaya. KELP-CS (Kids Engaged in Learning Programming) is an innovative, modular computational thinking curriculum for 4th-6th grade students. Off-computer activities connect computer science concepts to students' every day experiences. On-computer activities in LaPlaya develop students' computational thinking and programming skills. Finally, an engineering design project allows students to apply these new skills through an open-ended, creative project (e.g. digital storytelling in Module 1, and virtual game in Module 2). LaPlaya is a modified Scratch programming environment tailored to the developmental needs of 4th-6th grade students. In this workshop, we begin by introducing the KELP-CS curriculum; LaPlaya, the development environment used in the on-computer activities; and the resources for teachers embedded in both. Workshop participants will do sample on- and off- computer activities from Module 1 (4th grade) and discuss tips and strategies for teaching computational thinking with this age group. For the second part of the workshop, we provide additional background for participants interested in creating their own curriculum with LaPlaya. This includes how to create projects and their analysis.

The recent growth of interest in computer science has created a movement to more readily introduce computer science in K-12 classrooms. However, little research exists on how to successfully bring computer science to lower grade levels. In this paper, we present advice for researchers and curriculum developers who are getting started working with computer science in elementary schools. Specifically, we focus on practical tips for studies of this nature, developed from our experiences piloting a computational thinking curriculum with 4th-6th grade students. We address issues arising in elementary school classrooms such as recruiting and interfacing with teachers and schools, classroom management strategies, student computer literacy and developmental stages, and curriculum life cycles.

The recent renaissance in early computer science education has provided K-12 teachers with multiple options for introducing children to computer science. However, tools for teaching programming for children with wide-scale adoption have been targeted mostly at pre-readers or middle school and higher grade-levels. This leaves a gap for 4th -- 6th grade students, who differ developmentally from older and younger students.

Cache-coherent shared memory is critical for programmability in many-core systems. Several directory-based schemes have been proposed, but dynamic, non-uniform sharing make efficient directory storage challenging, with each giving up storage space, performance or energy.

Recent hardware trends point to increasingly deeper cache hierarchies. In such hierarchies, accesses that lookup and miss in every cache involve significant energy consumption and degraded performance. To mitigate these problems, in this paper we propose Recalibrating Deep Hierarchy Prediction (ReDHiP), an architectural mechanism that predicts last-level cache (LLC) misses in advance. An LLC miss means that all cache levels need not be accessed at all. Our design for ReDHiP focuses on a simple, compact prediction table that can be efficiently recalibrated over time. We find that a simpler scheme, while sacrificing accuracy, can be more accurate per bit than more complex schemes through recalibration. Our evaluation shows that ReDHiP achieves an average of 22% cache energy savings and 8% performance improvement for a wide range of benchmarks. ReDHiP achieves these benefits at a hardware cost of less than 1% of the LLC. We also demonstrate how ReDHiP can be used to reduce the energy overhead of hardware data prefetching while being able to further improve the performance.

The desire to expose more students to computer science has led to the development of a plethora of educational activities and outreach programs to broaden participation in computer science. Despite extensive resources (time and money), they have made little impact on the diversity of students pursuing computer science. To realize large gains, computational thinking must be integrated into K-12 systems, starting with elementary school. In order to do so, existing resources need to be adapted for a school setting. To make a curriculum with lessons that build on each other over several years, and accountability for student learning, we need standards, an understanding of how students learn, and identification of what students know before exposure to the curriculum. In this paper, we present our detailed findings of what fourth graders know before encountering a computational thinking curriculum. Groups of students participated in activities modified from CS Unplugged in order to discover their knowledge (rather than provide instruction). We identify aspects of the activities students were able to complete successfully, and where they will need further instruction. We then explain how we used these results to modify our pilot curriculum.

Work in quantum computer architecture has focused on communication, layout and fault tolerance, largely driven by Shor's factorization algorithm. For the first time, we study a larger range of benchmarks and find that another critical issue is the generation of code sequences for quantum rotation operations. Specifically, quantum algorithms require arbitrary rotation angles, while quantum technologies and error correction codes provide only for discrete angles and operators. A sequence of quantum machine instructions must be generated to approximate the arbitrary rotation to the required precision.

Scratch programming has risen in prominence, not only as a potential language for K-12 computer science, but also in introductory college courses. Unfortunately, grading Scratch programs is time-consuming, requiring manual execution of each program. Automation of this process is greatly complicated by the very reason Scratch is an attractive introductory language--the projects are multimedia in nature, requiring eyes and ears to fully appreciate.

Many institutions have created and deployed outreach programs for middle school students with the goal of increasing the number and diversity of students who later pursue careers in computer science. While these programs have been shown to increase interest in computer science, there has been less work on showing whether participants learn computer science content.

Major advances in Merged Logic DRAM (MLD) technology coupled with the popularization of memory-intensive applications provide fertile ground for architectures based on Intelligent Memory (IRAM) or Processors-in-Memory (PIM). The contribution of this paper is to explore one way to use the current state-of-the-art MLD technology for general-purpose computers. To satisfy requirements of general purpose and low programming cost, we place the PIM chips in the memory system and let them default to plain DRAM if the application is not enabled for intelligent memory. Since wide usability is crucial, we identify and analyze a range of real applications for PIM. Based on the requirements of these applications and current technological constraints, we design a PIM chip and a PIM-based memory system. We call the chip FlexRAM. We describe FlexRAMs design and floorplan, and the resulting memory system. Evaluation of the system through simulations shows that 4 FlexRAM chips often allow a workstation to run 25-40 times faster.

Current resource provisioning schemes in Internet services leave servers less than 50% utilized almost all the time. At this level of utilization, the servers' energy efficiency is substantially lower than at peak utilization. A solution to this problem could be dynamically consolidating workloads into fewer servers and turning others off. However, services typically resist doing so, because of high response times during reactivation in handling traffic spikes. Moreover, services often want the memory and/or storage of all servers to be readily available at all times. In this article, we propose a family of barely alive active low-power server states that facilitates both fast reactivation and access to memory while in a low-power state. We compare these states to previously proposed active and idle states. In particular, we investigate the impact of load bursts in each energy-saving scheme. We also evaluate the additional benefits of memory access under low-power states with a study of a search service using a cooperative main-memory cache. Finally, we propose a system that combines a barely-alive state with the off state. We find that the barely alive states can reduce service energy consumption by up to 38%, compared to an energy-oblivious system. We also find that these energy savings are consistent across a large parameter space.

Memory size has long limited large-scale applications on high-performance computing (HPC) systems. Since compute nodes frequently do not have swap space, physical memory often limits problem sizes. Increasing core counts per chip and power density constraints, which limit the number of DIMMs per node, have exacerbated this problem. Further, DRAM constitutes a significant portion of overall HPC system cost. Therefore, instead of adding more DRAM to the nodes, mechanisms to manage memory usage more efficiently -- preferably transparently -- could increase effective DRAM capacity and thus the benefit of multicore nodes for HPC systems. MPI application processes often exhibit significant data similarity. These data regions occupy multiple physical locations across the individual rank processes within a multicore node and thus offer a potential savings in memory capacity. These regions, primarily residing in heap, are dynamic, which makes them difficult to manage statically. Our novel memory allocation library, {\it SBLLmallocShort}, automatically identifies identical memory blocks and merges them into a single copy. Our implementation is transparent to the application and does not require any kernel modifications. Overall, we demonstrate that {\it SBLLmalloc} reduces the memory footprint of a range of MPI applications by $32.03\%$ on average and up to $60.87\%$. Further, {\it SBLLmalloc} supports problem sizes for IRS over $21.36\%$ larger than using standard memory management techniques, thus significantly increasing effective system size. Similarly, {\it SBLLmalloc} requires $43.75\%$ fewer nodes than standard memory management techniques to solve an AMG problem.

A popular approach to introducing students to computer science is to involve middle-school students in engaging programming activities. One challenge in such a program is attracting students who are not already positively predisposed to computing.

Parallelism is the key to continued performance scaling in modern microprocessors. Yet we observe that this parallelism can often contain a surprising amount of instruction redundancy. We propose to exploit this redundancy to improve performance and decrease energy consumption. We propose a multi-threading micro-architecture, Minimal Multi-Threading (MMT), that leverages register renaming and the instruction window to combine the fetch and execution of identical instructions between threads in SPMD applications. While many techniques exploit intra-thread similarities by detecting when a later instruction may use an earlier result, MMT exploits inter-thread similarities by, whenever possible, fetching instructions from different threads together and only splitting them if the computation is unique. With two threads, our design achieves a speedup of 1.15 (geometric mean) over a two-thread traditional SMT with a trace cache. With four threads, our design achieves a speedup of 1.25 (geometric mean) over a traditional SMT processor with four-threads and a trace cache. These correspond to speedups of 1.5 and 1.84 over a traditional out-of-order processor. Moreover, our performance increases in most applications with no power increase because the increase in overhead is countered with a decrease in cache accesses, leading to a decrease in energy consumption for all applications.

While microprocessor designers turn to multicore architectures to sustain performance expectations, the dramatic increase in parallelism of such architectures will put substantial demands on off-chip bandwidth and make the memory wall more significant than ever. This paper demonstrates that one profitable application of multicore processors is the execution of many similar instantiations of the same program. We identify that this model of execution is used in several practical scenarios and term it as "multi-execution." Often, each such instance utilizes very similar data. In conventional cache hierarchies, each instance would cache its own data independently. We propose the Mergeable cache architecture that detects data similarities and merges cache blocks, resulting in substantial savings in cache storage requirements. This leads to reductions in off-chip memory accesses and overall power usage, and increases in application performance. We present cycle-accurate simulation results of 8 benchmarks (6 from SPEC2000) to demonstrate that our technique provides a scalable solution and leads to significant speedups due to reductions in main memory accesses. For 8 cores running 8 similar executions of the same application and sharing an exclusive 4-MB, 8-way L2 cache, the Mergeable cache shows a speedup in execution by 2.5x on average (ranging from 0.93x to 6.92x), while posing an overhead of only 4.28% on cache area and 5.21% on power when it is used.

We present Synchroscalar, a tile-based architecture for embedded processing that is designed to provide the flexibility of DSPs while approaching the power efficiency of ASICs. We achieve this goal by providing high parallelism and voltage scaling while minimizing control and communication costs. Specifically, Synchroscalar uses columns of processor tiles organized into statically-assigned frequency-voltage domains to minimize power consumption. Furthermore, while columns use SIMD control to minimize overhead, data-dependent computations can be supported by extremely flexible statically-scheduled communication between columns. We provide a detailed evaluation of Synchroscalar including SPICE simulation, wire and device models, synthesis of key components, cycle-level simulation, and compiler- and hand-optimized signal processing applications. We find that the goal of meeting, not exceeding, performance targets with data-parallel applications leads to designs that depart significantly from our intuitions derived from general-purpose microprocessor design. In particular, synchronous design and substantial global interconnect are desirable in the low-frequency, low-power domain. This global interconnect supports parallelization and reduces processor idle time, which are critical to energy efficient implementations of high bandwidth signal processing. Overall, Synchroscalar provides programmability while achieving power efficiencies within 8-30/spl times/ of known ASIC implementations, which is 10-60/spl times/ better than conventional DSPs. In addition, frequency-voltage scaling in Synchroscalar provides between 3-32% power savings in our application suite.

The Active Pages model of intelligent memory can speed up data-intensive applications by up to two to three orders of magnitude over conventional systems. A fundamental problem with intelligent memory, however, arises when data cached by the processor is modified by logic in the memory. The Active Page model inherently limits sharing, keeping coherence tractable, but exacerbates saturation problems. We first present a hybrid snoopy/directory protocol for use in Active Pages. Limited sharing allows for a low-latency, low-bandwidth hybrid protocol. A transparent remapping mechanism is added for efficient caching. On smaller data sizes, explicit flushing and hardware coherence exhibit similar performance, but hardware coherence is easier to program and uses less bandwidth. Finally, we examine SMP multiprocessor systems to mitigate saturation effects. As the number of threads increases, the bandwidth needs increase, making hardware coherence even more attractive.

Active Pages is a page-based model of intelligent memory specifically designed to support virtualized hardware resources. Previous work has shown substantial performance benefits from off loading data-intensive tasks to a memory system that implements Active Pages. With a simple VLIW processor embedded near each page on DRAM, Active Page memory systems achieve up to 1000X speedups over conventional memory systems. In this study, we examine Active Page memories that share, or multiplex, embedded VLIW processors across multiple physical Active Pages. We explore the trade-off between individual page-processor performance and page-level multiplexing. We find that hardware costs of computational logic can be reduced from 31% of DRAM chip area to 12%, through multiplexing, without significant loss in performance. Furthermore, manufacturing defects that disable up to 50% of the page processors can be tolerated through efficient resource allocation and associative multiplexing.

Major advances in merged logic DRAM (MLD) technology coupled with the popularization of memory-intensive applications provide fertile ground for architectures based on intelligent memory (IRAM) or processors-in-memory (PIM). The contribution of this paper is to explore one way to use the current state-of-the-art MLD technology for general-purpose computers. To satisfy requirements of general purpose and low programming cost, we place the PIM chips in the memory system and let them default to plain DRAM if the application is not enabled for intelligent memory. Since wide usability is crucial, we identify and analyze a range of real applications for PIM. Based on the requirements of these applications and current technological constraints, we design a PIM chip and a PIM-based memory system. We call the chip FlexRAM. We describe FlexRAM's design and floorplan, and the resulting memory system. Evaluation of the system through simulations shows that 4 FlexRAM chips often allow a workstation to run 25-40 times faster.

This study compares the speed, area, and power of different implementations of Active Pages, an intelligent memory system which helps bridge the growing gap between processor and memory performance by associating simple functions with each page of data. Previous investigations have shown up to 1000X speedups using a block of reconfigurable logic to implement these functions next to each subarray on a DRAM chip. In this study, we show that instruction-level parallelism, not hardware specialization, is the key to the previous success with reconfigurable logic. In order to demonstrate this fact, an Active Page implementation based upon a simplified VLIW processor was developed. Unlike conventional VLIW processors, power and area constraints lead to a design which has a small number of pipeline stages. Our results demonstrate that a four-wide VLIW processor attains comparable performance to that of pure FPGA logic but requires significantly less area and power.