Article

How block-based, text-based, and hybrid block/text modalities shape novice programming practices

If you want to read the PDF, try requesting it from the authors.

Abstract

There is growing diversity in the design of introductory programming environments. Where once all novices learned to program in conventional text-based languages, today, there exists a growing ecosystem of approaches to programming including graphical, tangible, and scaffolded text environments. To date, relatively little work has explored the relationship between the design of novice programming environments and the programming practices they engender in their users. This paper seeks to shed light on this dimension of learning to program through the careful analysis of novice programmers’ experiences learning with a hybrid block/text programming environment. Specifically, this paper is concerned with how novices leverage the various affordances designed into programming environments and programming languages to support their early efforts to author programs. We explore this relationship through the construct of modality using data from a study conducted in a high school computer science classroom in which students spent five weeks working in block-based, text-based, and hybrid block/text programming environments. This paper uses a detailed vignette of a novice writing a program in the hybrid environment as a way to characterize emerging programming practices, then presents analyses of programming trends from the full study population to speak to the generality of the practices identified in the vignette. The analyses focus not only on characterizing authoring strategies but also on identifying patterns in novices’ help-seeking behaviors. By focusing on how modality influences novices’ emerging programming practices, this paper contributes to our understanding of the relationship between programming environment and learning, illuminating the role of design in shaping introductory programming experiences.

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... Subsequently, in the last decade, new programming environments are combining both BPLs and TBPLs. Examples for such dual-modality environments (Weintrop & Wilensky, 2018) are PencilCode and TiledGrace, where learners in the same program can switch back and forth between BPL and TBPL. Another programming environments are hybrid block/text settings where BPL and TBPL characteristics are combined into new one sharing characteristics of both (Weintrop & Wilensky, 2018). ...
... Examples for such dual-modality environments (Weintrop & Wilensky, 2018) are PencilCode and TiledGrace, where learners in the same program can switch back and forth between BPL and TBPL. Another programming environments are hybrid block/text settings where BPL and TBPL characteristics are combined into new one sharing characteristics of both (Weintrop & Wilensky, 2018). ...
... Other studies reported a loss of students confidence after transitioning to TBPL (Moors et al., 2018) and difficulty transitioning from BPL to even pseudocode or flowcharts (Chetty & Barlow-Jones, 2012). When it comes to hybrid environments (combined use of BPL and TBPL), some conducted studies showed that students using such a hybrid environment performed better in TBPL after the transition than students using BPL (Alrubaye et al., 2019;Weintrop & Wilensky, 2018). ...
Article
Since its beginnings in the 1970s, learning to program is a challenging task for learners and educators. In the last two decades, many attempts were made to increase learning programming’s popularity, resulting in the development of block-based programming languages (BPL), widely used to engage children in programming from an early age. The use of BPL showed the benefits for K-12 programming novices in lowering the barrier towards programming. However, by using a BPL as the only programming language, or even using it for a more extended period of time, there is a risk that students will not transfer learned programming concepts to the “real” text-based programming language (TBPL). There is a lack of theoretical or empirical studies dealing with transferring BPL to TBPL at the K-12 level. This study is designed to investigate the effects of BPL MakeCode for micro:bit using a pedagogical approach of mediated transfer for the transfer of learned programming concepts to “real” TBPL Python. According to the national curriculum among 49 sixth graders in the classroom settings, the quasi-experiment was conducted during programming lectures according to the national curriculum. Results confirmed that BPL could successfully be used as a mediated transfer medium to understand the programming concepts in the TBPL. Link for download: https://authors.elsevier.com/a/1cnUi7t9Un~83q
... During programming via block-based tools cannot perform teaching a real programming language to students, whereas programming in hybrid interface can. A programming tool which has hybrid interface blends features of block-based and text-based programming environments (Goudouris et al., 2020;Noone & Mooney, 2018;Weintrop & Wilensky, 2018). Blockly suggested in 2012 by Google, is similar to hybrid programming tools. ...
... cc) (Seraj et al., 2019;Weintrop & Wilensky, 2019). However, it is available a few studies comparing hybrid interface versus text-based interface in programming language education (Yiğit, 2016;Weintrop & Wilensky, 2018). In our study, students in experimental group using Blockly (hybrid interface) and in control group using Python editor (non-hybrid interface) have performed 10-week programming tasks from easier to more difficult. ...
... It is important to find the easiest way make students learn a programming language, in order to increase efficiency of learning process (Tuomi et al., 2018). It can be said that programming tools with hybrid interface (Goudouris et al., 2020;Noone & Mooney, 2018;Weintrop & Wilensky, 2018) such as Blockly are more attractive and effective for students' future programming experiences (Ashrov et al., 2015;Seraj et al., 2019). Therefore, it is recommended that Blockly (hybrid interface) is used widely in programming language education (Bubnó & Takács, 2017 Informed consent Informed consent was obtained from all individual participants included in the study. ...
Article
Full-text available
In this study, based on quasi-experimental research, was investigated the effects of teaching Python programming language via Blockly tool, which had hybrid interface, on students’ computer programming anxiety, cognitive load level, and achievement. Participants were 90 high school students, 44 of them in experimental group (hybrid interface) and 46 of them in control group (non-hybrid interface). According to results, there was a meaningful difference between programming achievement scores of students in favor of experimental group while there was no difference in terms of computer programming anxiety between groups. Moreover, after 10-week implementation process, students’ anxiety increased in each group. It was found out cognitive load levels of both groups in the first week were higher than final week. Although both weekly and 10-week intrinsic, extraneous, germane, and total cognitive load levels of experimental group were lower than control group, there was no significantly difference between groups. Consequently, it can be said that programming via hybrid interface, using Blockly, has not an effect on students’ computer programming anxiety positively whereas it helps to keep cognitive load at low level and to increase students’ programming success more. It is recommended that considering these results to make computer programming education is more efficient in high schools and administrators encourage the teachers to use programming tool had hybrid interface such as Blockly.
... Studien wie die von Bau u. a. [12], Boshernitsan und Downes [14], Green und Petre [53], Noone und Mooney [82], Weintrop und Wilensky [112] und Whitley [115] scheinen zu belegen, dass visuelle Programmierung ein starkes Konzept für Anfänger und Nicht-Programmierer darstellt, für die Entwicklung komplexer Software und die Beschreibung abstrakter Strukturen jedoch weniger adäquat ist. ...
... Weintrop und Wilensky [112] unterscheiden bei diesen heterogenen Systemen zwei Varianten: Entweder werden ein textueller und ein visueller Modus unterstützt oder textuelle Elemente werden in eine visuelle Umgebung integriert. ...
... Stattdessen kann prinzipiell an jeder Stelle im Code sowohl ein textuelles als auch ein visuelles Element verwendet werden. Somit gehört unser Ansatz nicht zu der ersten der von Weintrop und Wilensky [112] unterschiedenen Kategorien heterogener Systeme (s. Abschnitt 2.3.3). ...
Book
Visuelle Programmiersprachen werden heutzutage zugunsten textueller Programmiersprachen nahezu nicht verwendet, obwohl visuelle Programmiersprachen einige Vorteile bieten. Diese reichen von der Vermeidung von Syntaxfehlern, über die Nutzung konkreter domänenspezifischer Notation bis hin zu besserer Lesbarkeit und Wartbarkeit des Programms. Trotzdem greifen professionelle Softwareentwickler nahezu ausschließlich auf textuelle Programmiersprachen zurück. Damit Entwickler diese Vorteile visueller Programmiersprachen nutzen können, aber trotzdem nicht auf die ihnen bekannten textuellen Programmiersprachen verzichten müssen, gibt es die Idee, textuelle und visuelle Programmelemente gemeinsam in einer Programmiersprache nutzbar zu machen. Damit ist dem Entwickler überlassen wann und wie er visuelle Elemente in seinem Programmcode verwendet. Diese Arbeit stellt das SandBlocks-Framework vor, das diese gemeinsame Nutzung visueller und textueller Programmelemente ermöglicht. Neben einer Auswertung visueller Programmiersprachen, zeigt es die technische Integration visueller Programmelemente in das Squeak/Smalltalk-System auf, gibt Einblicke in die Umsetzung und Verwendung in Live-Programmiersystemen und diskutiert ihre Verwendung in unterschiedlichen Domänen.
... These are namely, block-based and text-based educational programming languages. While there are many different types of educational programming languages and platforms, the two categories noted above are the most predominant when used in delivering key programming concepts to novice learners [15], [36], [37]. A comparison between the various platform and language features exhibited by both block-based and text-based introductory programming languages, including the programming environment, programming language, and other supporting features such as the target audience and language extensibility is described in Table 2 below [2], [13], [16]- [18], [36], [37]. ...
... While there are many different types of educational programming languages and platforms, the two categories noted above are the most predominant when used in delivering key programming concepts to novice learners [15], [36], [37]. A comparison between the various platform and language features exhibited by both block-based and text-based introductory programming languages, including the programming environment, programming language, and other supporting features such as the target audience and language extensibility is described in Table 2 below [2], [13], [16]- [18], [36], [37]. Furthermore, due to the high availability of these educational programming platforms, especially in the blockbased category, it was decided to exclude any block-based programming language which did not have its own stable programming environment from this review. ...
... These are namely, block-based and text-based educational programming languages. While there are many different types of educational programming languages and platforms, the two categories noted above are the most predominant when used in delivering key programming concepts to novice learners [15], [36], [37] ...
Article
Full-text available
Delivery of core programming principles to novices is a challenging task and many introductory programming languages and platforms have been designed to support this process. Educational programming languages generally focus on alleviating the syntax overhead enforced on novice learners by designing languages with simple and concise keywords. Furthermore, only the most basic programming concepts and principles are incorporated and many languages follow unique methods to provide more simplified learning environments. However, considering the way programs are authored using these platforms, two common contrasting approaches to program representation are identified as text-based and block-based representations. Additionally, a hybrid approach of dual-modality interfaces, which combines the best of both techniques has gained traction as a current trend in the development of educational programming platforms. However, despite these extensive features, not all introductory programming languages can cater to the exact requirements of novice learners and a dearth of comprehensive studies and literature reviews have been conducted to investigate this context. This paper explores and presents a comprehensive review of how different elements of educational programming languages and platforms contribute towards learning by novices under the Technology Acceptance Model (TAM). The review is conducted under two main constructs of TAM as (1) Perceived Usefulness (PU) and (2) Perceived Ease of Use (PEOU) and external factors regarding the programming environment, language design, included programming concepts and supporting features such as the target audience group, language extensibility, and availability of learning materials are thoroughly investigated considering the typical behavioral patterns of novices concerning computer programming education.
... Interaction logging has been used to effectively gather data describing user's behaviour in creative disciplines. With regard to block-based programming, Weintrop and Wilensky [21] used data-logging to discover how different modalities influenced students' programming practices. In music, Wu [22] used interaction data to evaluate the capacity of different paradigms in supporting non-musicians' creative engagement. ...
... Related work further supports this notion, recommending that creative user interfaces provide ample help mechanisms or a more intuitive UI design[24][25][29].However, the finding that children only dedicated a small proportion of their interactions to discovering help documentation suggests that the built-in didactic material was largely ignored, or never used. Researchers of block-based interfaces have found similar issues in the domain of computer science[30][21]. Perhaps, there is an opportunity to compliment the exploratory work presented here, looking for more concrete areas where children are 'stuck', and providing support.The analysis presented here is also limited by the small sample size and user's levels of experience; the data only reflects a glimpse into first-time novice interaction. ...
Conference Paper
Full-text available
Composing is a neglected area of music education. To increase participation, many technologies provide open-ended interfaces to motivate child autodidactic use, drawing influence from Papert’s LOGO philosophy to support children’s learning through play. This paper presents a case study examining which interactions with Codetta, a LOGO-inspired, block-based music platform, supports children’s creativity in music composition. Interaction logs were collected from 20 children and correlated against socially-validated creativity scores. To conclude, we recommend that the transition between low-level edits and high-level processes should be carefully scaffolded.
... Programming environments and languages for education undergo tremendous change, and every year new environments and tools emerge. This compels educational researchers to investigate if and how the emerging learning environments and tools affect the learning outcomes of learners and the difficulties that they may experience when developing certain CT skills [3,71]. The micro:bit is a "RAM-based programmable Internet of Things (IoT) device" created by the BBC to train children about programming and preliminary computing principles [72,73]. ...
... The former provides users with JavaScript programming experience, and the latter supports Python. These features characterise the micro:bit as a hybrid block/text programming environment [71], in which users can switch back-and-forth between the block-based and text-based editors. A wide range of educational projects can be implemented using the micro:bit device, ranging from developing classical and interactive games (e.g., rock, paper, scissors game), to building prototypes to track, monitor, and simulate objects in environments (e.g., a prototype to monitor how climate change affects animals), to helping people with special needs (e.g., a prototype tool to support autistic people in communicating with others) [74,75]. ...
Article
Full-text available
Computational Thinking (CT) has been investigated from different perspectives. This research aims to investigate how secondary school girls perceive CT practices -- the problem-solving practices that students apply while they are engaged in programming -- when using the micro:bit device in a collaborative setting. This study also explores the collaborative programming process of secondary school girls with the micro:bit device. We conducted mixed-methods research with 203 secondary school girls (in the state of Victoria, Australia) and 31 mentors attending a girls-only CT program (OzGirlsCT program). The girls were grouped into 52 teams and collaboratively developed computational solutions around realistic, important problems to them and their communities. We distributed two surveys (with 193 responses each) to the girls. Further, we surveyed the mentors (with 31 responses) who monitored the girls, and collected their observation reports on their teams. Our study indicates that the girls found “debugging” the most difficult type of CT practice to apply, while collaborative practices of CT were the easiest. We found that prior coding experience significantly reduced the difficulty level of only one CT practice - “debugging”. Our study also identified six challenges the girls faced and six best practices they adopted when working on their computational solutions.
... Programming environments and languages for education undergo tremendous change, and every year new environments and tools emerge. This compels educational researchers to investigate if and how the emerging learning environments and tools affect the learning outcomes of learners and the difficulties that they may experience when developing certain CT skills [3,71]. The micro:bit is a "RAM-based programmable Internet of Things (IoT) device" created by the BBC to train children about programming and preliminary computing principles [72,73]. ...
... The former provides users with JavaScript programming experience, and the latter supports Python. These features characterise the micro:bit as a hybrid block/text programming environment [71], in which users can switch back-and-forth between the block-based and text-based editors. A wide range of educational projects can be implemented using the micro:bit device, ranging from developing classical and interactive games (e.g., rock, paper, scissors game), to building prototypes to track, monitor, and simulate objects in environments (e.g., a prototype to monitor how climate change affects animals), to helping people with special needs (e.g., a prototype tool to support autistic people in communicating with others) [74,75]. ...
Preprint
Computational Thinking (CT) has been investigated from different perspectives. This research aims to investigate how secondary school girls perceive CT practices -- the problem-solving practices that students apply while they are engaged in programming -- when using the micro:bit device in a collaborative setting. This study also explores the collaborative programming process of secondary school girls with the micro:bit device. We conducted mixed-methods research with 203 secondary school girls (in the state of Victoria, Australia) and 31 mentors attending a girls-only CT program (OzGirlsCT program). The girls were grouped into 52 teams and collaboratively developed computational solutions around realistic, important problems to them and their communities. We distributed two surveys (with 193 responses each) to the girls. Further, we surveyed the mentors (with 31 responses) who monitored the girls, and collected their observation reports on their teams. Our study indicates that the girls found "debugging" the most difficult type of CT practice to apply, while collaborative practices of CT were the easiest. We found that prior coding experience significantly reduced the difficulty level of only one CT practice - "debugging". Our study also identified six challenges the girls faced and six best practices they adopted when working on their computational solutions.
... El enfoque y los entornos de programación basada en bloques demuestran ser una opción efectiva para introducir conceptos y prácticas fundamentales sobre algoritmos y programación a estudiantes sin formación previa en elárea de conocimiento [19]. ...
... En este sentido, se busca sostener las ventajas de la representación gráfica y característica de mapeo directo de las operaciones sobre el escenario con intención de posibilitar una retroalimentaciónágil y la detección y corrección de errores. Al mismo tiempo que se mantiene la tarea en el plano de lo concreto se proporciona flexibilidad, versatilidad y legibilidad de texto [19]. ...
Conference Paper
Full-text available
El enfoque de programación por bloques demuestra ser una opción efectiva para dar los primeros pasos en el arte de programar. Se espera que en el transcurso de la escuela secundaria los estudiantes logren desarrollar programas usando lenguajes basados en texto. El paso a un entorno de programación tradicional, como Netbeans+Java, suele resultar un proceso frustrante para la mayoría de los estudiantes. Este artículo presenta una revisión sobre entornos diseñados para favo-recer y facilitar los procesos de transición de programación basada en bloques a programación basada en texto. Estos entornos buscan hacer más accesible la programación tradicional para estudiantes con experiencia previa en ambientes basados en bloques y posiblemente reducir la curva de aprendizaje como también los niveles de frustración. Además, este artículo presenta un modelo que permite evaluar estos re-cursos y constituye una herramienta para orientar los procesos de espe-cificación y desarrollo de este tipo de entornos.
... These allow composing blocks to create applications that are highly visual and aesthetically pleasant. The color of the blocks sup ports children by helping them in recognizing functions and which blocks can be composed together [50]. This process re duces the cognitive load of text-based languages. ...
... There is no or very little pedagogical guidance on how to teach second and subsequent programming languages. Such guidance is of great importance given the transition challenges students face as they switch between PLs [1,2,4,8,9,11,13,16,28,31,32]. ...
Conference Paper
Full-text available
Students are expected to move from one programming language (PL) to another in their computer science education. Recent work has proposed a model of PL transfer to explain how students trans- fer conceptual knowledge between languages. This model suggests that during the transition, learners automatically effect a transfer of semantics between languages based on syntax similarities. The semantic transfer can be positive for learning when the syntax and semantics of the new PL are similar to the prior PL (True Carryover Constructs) and becomes negative when the syntax of the prior PL is similar to the new PL but the semantics are different (False Carryover Constructs). To avoid negative semantic transfer during learning, this study aims to investigate the effectiveness of explicit instruction in teaching a second PL by conducting two empirical studies. Study 1 was a within-subject study that investigated under- graduate students transitioning from procedural Python to object- oriented Java. Study 2 was a between-subject study that investigated undergraduate students transitioning from object-oriented Python to object-oriented Java at a different university. The results of both studies show that students benefited significantly more on interven- tions on the False Carryover Constructs categories than the True Carryover Constructs. These findings can help teachers interpret and improve their own classroom practices when teaching second PLs.
... By comparison, however, there is very limited research on how students move on to learn a second and subsequent PL, when they already have established conceptual knowledge from their first programming language. Finding the answer to this question is particularly important because several studies reported transition challenges relative novices face as they switch between programming languages [1,2,5,13,16,18,24,26,28,48,50,51]. ...
Conference Paper
Full-text available
Prior research has shown that students face transition challengesbetween programming languages (PL) over the course of theireducation. We could not find research attempting to devise a modelthat describes the transition process and how students’ learning ofprogramming concepts is affected during the shift. In this paper, wepropose a model to describe PL transfer for relative novices. In themodel, during initial stages of learning a new language, studentswill engage in learning three categories of concepts, True CarryoverConcepts, False Carryover Concepts, or Abstract True CarryoverConcepts; during the transition, learners automatically effect atransfer of semantics between languages based on syntax matching.In order to find support for the model, we conducted two empiricalstudies. Study 1 investigated near-novice undergraduate studentstransitioning from procedural Python to object-oriented Java whileStudy 2 investigated near-novice postgraduate students doing atransfer from object-oriented Java to procedural Python. Results forboth studies indicate that students had little or no difficulty withtransitioning on TCC due to positive semantic transfer based onsyntax similarities while they had the most difficulty transitioningon FCC due to negative semantic transfer. Students had little or nosemantic transfer on ATCC due to differences in syntax betweenthe languages. We suggest ways in which the model can informpedagogy on how to ease the transition process.
... Students enrolled in university classes could post questions to public forums and could also ask for 1-on-1 help from a peer, who would be located by an i-Help agent. There is also work outside the AIED community on supporting novices through the design of environments for programming activities (Costa and Miranda 2017;Whittall et al. 2017;Bau et al. 2017;Weintrop and Wilensky 2018). ...
Article
When students are first learning to program, they not only have to learn to write programs, but also how to trace them. Code tracing involves stepping through a program step-by-step, which helps to predict the output of the program and identify bugs. Students routinely struggle with this activity, as evidenced by prior work and our own experiences in the classroom. To address this, we designed a Code Tracing (CT)-Tutor. We varied the level of assistance provided in the tutor, based on (1) the interface scaffolding available during code tracing, and (2) instructional order, operationalized by when examples were provided, either before or after the corresponding problem was solved. We collected data by having participants use the tutor to solve code tracing problems (N = 97) and analyzed both learning outcomes and process data obtained by extracting features of interest from the log files. We used a multi-layered approach for the analysis, including standard inferential statistics and unsupervised learning to cluster students by their behaviors in the tutor. The results show that the optimal level of assistance for code tracing falls in the middle of the assistance spectrum included in the tutor, but also that there are individual differences in terms of optimal assistance for subgroups of individuals. Based on these results, we outline opportunities for future work around personalizing instruction for code tracing.
... Research on this approach has shown students have similar learning gains as those in traditional environments, but progress more quickly and have fewer issues related to language syntax (Price, Brown, Lipovac, Barnes, & Kölling, 2016). Further research looking at novices working in dual-modality environments has revealed that learners take advantage of aspects of both modalities as they work, making it distinct from working in either a fully blocks-based or fully text-based environment (Weintrop & Wilensky, 2018). The active development of such environments speaks to the current relevance of the proposed study, which seeks to understand how block-based environments do and do not support learners in their transition to textbased languages. ...
... However, programming is a challenging subject for students-especially novices-to perceive and learn (Baser, 2013;Durak, 2016;Kelleher et al., 2007). When beginners learn to program in the initial operating stage by utilizing text-based programming tools (e.g., Python, Java, C), overly complicated program syntax might make them feel frustrated, and, thus, reduce their enthusiasm for learning how to program (Altun & Mazman, 2012;Chang et al., 2017;Gomes & Mendes, 2007;Guzdial, 2004;Kinnunen & Malmi, 2006;Lahtinen et al., 2005;Salleh et al., 2013;Topalli & Cagiltay, 2018;Weintrop & Wilensky, 2018). ...
Article
Block-based visual programming tools, such as Scratch, Alice, and MIT App Inventor, provide an intuitive and easy-to-use editing interface through which to promote programming learning for novice students of various ages. However, very little attention has been paid to investigating these tools' overall effects on students' academic achievement and the study features that may moderate the effects of block-based visual programming from a comprehensive perspective. Thus, the present study carried out a meta-analysis to systemically examine 29 empirical studies (extracting 34 effect sizes) using experimental or quasi-experiments involving the programming learning effects of employing block-based visual programming tools to date (until the end of 2019). The results showed a small to medium significant positive overall mean effect size (fixed-effect model g = 0.37; random-effects model g = 0.47) of the use of these block-based visual programming tools with respect to students' academic achievement. Furthermore, the overall mean effect size was significantly affected by the educational stage, programming tool used, experimental treatment, and school location. Discussions and implications based on the findings are provided.
... On the other hand, program comprehension [27] in other research fields has been examined extensively. For example, the comprehension of block-based programming vs. text-based programming [28,29], studying the impact of anti-patterns on program comprehension [30], comprehension of DSL programs vs. GPL programs [15,16,31,32], model comprehension [33], comparison of a textual vs. a graphical notation in domain models [34], the influence of visual notation to requirement specification comprehension [35], comprehension of charts for visually impaired individuals [36], program comprehension in virtual reality [37], software maintenance [38], and software engineering [39]. ...
Article
Full-text available
Applied to the problem of automatic program generation, Genetic Programming often produces code bloat, or unexpected solutions that are, according to common belief, difficult to comprehend. To study the comprehensibility of the code produced by Genetic Programming, attribute grammars obtained by Genetic Programming-based semantic inference were compared to manually written ones. According to the established procedure, the research was carried out as a controlled classroom experiment that involved two groups of students from two universities, and consisted of a background questionnaire, two tests and a feedback questionnaire after each test. The tasks included in the tests required the identification of various properties of attributes and grammars, the identification of the correct attribute grammar from a list of choices, or correcting a semantic rule in an attribute grammar. It was established that solutions automatically generated by Genetic Programming in the field of semantic inference, in this study attribute grammars, are indeed significantly harder to comprehend than manually written ones. This finding holds, regardless of whether comprehension correctness, i.e., how many attribute grammars were correctly comprehended, or comprehension efficiency is considered, i.e., how quickly attribute grammars were correctly comprehended.
... Other studies that identified similar challenges are [14,34,35]. Attempts to address these transition issues mostly create tools to support interfaces with both visual and corresponding text language for students to form analogies at the text surface (syntax) as they transition [3,6,9,36]. ...
Conference Paper
Full-text available
It is a natural part of a student's computing education to transfer from language to language, hence adopting to a new programming language (PL) quickly is a necessary skill. Prior work in computer science research mainly brings awareness of the success and difficulties that students face when learning new languages. In addition, work that directly relates to PL transfer mainly concerns experienced programmers problem solving in a new language, evidencing plan transfer. We could not find research attempting to devise a model of PL transfer based on code comprehension. We explore this phenomenon in the context of five university students transitioning from procedural Python to object-oriented Java, over a period of 10 weeks. We analyse the results through the lens of a model of second language acquisition using the notion of Semantic transfer and the Mindshift learning theory (MLT). The findings indicate that during the initial learning stages, learners relied mostly on their syntactic matching between Python and Java and subsequent semantic transfer which affected their learning positively on Carryover concepts and negatively on Changed concepts. Students could not transfer their semantic knowledge on concepts they perceived as Novel. An understanding of the transfer process learners go through during a shift can help inform our pedagogy on how to ease the transition process and achieve an effective learning process, and we provide pointers in this direction.
... Second, using several, differently working languages may help students to have a deeper understanding of the computational concepts, by seeing both the similarities and the differences between the environments, so they can generalize and abstract the relevant concepts. Similarly, there is a debate whether educational tools should be graphical or text-based or combined (Weintrop & Wilensky, 2018). Using a text-based environment, such as AlgoTaurus, and a graphical tool, like Scratch, may be another source of deeper understanding of computational concepts. ...
Article
Full-text available
An educational computer game is presented, used for beginner students to introduce some basic concepts of code execution and code writing. In this mini-language microworld game, a code should be written with which a robot can escape from a procedurally generated labyrinth. The game uses a simple language and utilizes a virtual environment, where code execution could be tracked easily. One essential advantage of the software is that after a very short training, students can start experimenting, and they can understand many basic properties of code writing and execution. Based on several pilot teaching classes in both primary schools and universities, the game is an efficient tool to introduce the bases of computer programming, which bases might be harder to demonstrate with other educational tools.
... Other strategies investigated include documenting how learners at different ages design for their audiences [19] and debugging strategies and the requisite knowledge to implement them [28]. Further work has documented programming strategies specific to VBBPEs, looking at how the scaffolds present in the environment support unique patterns of interaction [52]. Likewise, a growing body of research is documenting how novices learn with block-based tools; identifying misconceptions learners may develop in VBBPEs and developmentally-appropriate content for learners [15,16,42]. ...
Conference Paper
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.
... Finally, Scratch's wide walls provided multiple pathways coders of diverse ability levels could take while learning (Resnick et al., 2009). As a result, students in our case study were able to practice assembling programs in Scratch without getting bogged down in the syntactical requirements of traditional programming languages (Weintrop & Wilensky, 2018). ...
Article
Full-text available
Background and Context: Computational Thinking (CT) is a skill all students should learn. This requires using inclusive approaches to teach CT to a wide spectrum of students. However, strategies for teaching CT to students with exceptionalities are not well studied. Objective: This study draws on lessons learned in two fourth-grade classrooms-one an inclusive general education classroom including students with and without disabilities, the other an inclusive GATE classroom including students with and without giftedness-to illustrate how CT frameworks can inform inclusive CS instruction. Method: A comparative case study design integrating content analysis and first and second cycle coding of data was used to analyze teachers' instructional strategies using a CT framework. Data included transcriptions of audio-recorded classroom lessons, field notes, and conversations with teachers and students. Findings: While each teacher used different strategies, both were effective in developing students' CT. Explicit instruction provided students receiving special education services with needed structure for the complex tasks inherent to computing. Peer feedback facilitated independent computational practice opportunities for students receiving GATE. Implications: This study highlights how inclusive instructional practices can be assessed using a CT framework and leveraged to maximize learning and access to CT curricula for learners with exceptionalities.
... That is to say, students scored the same on the assessment after ten weeks of Java instruction regardless of which introductory environment they used, so the gains found after five weeks for students learning in the block-based environment were no longer present. We also found there to be no significant difference in terms of the programming practices employed while authoring programs and that students from both introductory experiences showed similar patterns in the types and frequency of syntax errors encountered (Weintrop & Wilensky, 2018). One important thing to note about this study was that the teacher who taught these classes did not employ any specific pedagogical strategies to help bridge the transition from block-based to text-based programming. ...
Chapter
Full-text available
Computational thinking (CT) is a cognitive ability that is considered one of the core skills to be developed in order to successfully adapt to the future. Therefore, it is being included in school curricula all over the world and, gradually, at an earlier age. However, as the incorporation of CT learning in schools is recent, there is still no consensus on its exact definition or on how it should be assessed. Recent research suggests that systems of assessments should be used for this purpose, using various instruments, and thus covering the different CT dimensions. However, there is a lack of validated instruments for the assessment of CT, particularly for early ages. Taking as a reference a three-dimensional CT framework, based on a validated CT test, and aimed at early ages (five- to ten-year-old students), the Beginners Computational Thinking Test has been developed as a tool to be used within a system of assessments. This instrument has been designed, submitted to a content validation process through an expert judgement procedure, and administered to primary school students, obtaining very favourable results in terms of its reliability.
... Results revealed that only a few studies reported psychometric evidence (e.g., reliability and validity), as shown in Table 10. Most of the studies reviewed implemented their own assessment tools or adapted existing tools to serve their purposes, but did not report reliability or validity indicators (Fronza et al. 2017;Mouza et al. 2016;von Wangenheim et al. 2018;Weintrop and Wilensky 2018;Witherspoon et al. 2017). Some studies claimed that the tool they adopted had been validated by previous studies (Durak and Saritepeci 2018;Román-González et al. 2017, 2018a. ...
Article
Full-text available
Computational thinking (CT) is regarded as an essential twenty-first century competency and it is already embedded in K-12 curricula across the globe. However, research on assessing CT has lagged, with few assessments being implemented and validated. Moreover, there is a lack of systematic grouping of CT assessments. This scoping review examines 39 empirical studies published within the last five years, coded by the specific competencies outlined in existing CT frameworks, to identify and classify the key features of existing CT assessments. Results show that most studies target K-12 settings, focus on interventions that promote CT concepts and practices, adopt a quasi-experimental design, use selected-response items as the dominant testing form, and mainly assess algorithmic thinking, abstraction, problem decomposition, logical thinking, and data. Finally, few CT assessments have been validated in educational settings. Implications include identifying gaps in the CT assessment literature, deepening our understanding of the nature of CT, focusing on the validation of CT assessments, and guiding researchers and practitioners in choosing developmentally appropriate CT assessments. Cognitive and educational implications for future research inquiry include the development of new assessment tools that comprehensively assess CT and its relation to learning.
... That is to say, students scored the same on the assessment after ten weeks of Java instruction regardless of which introductory environment they used, so the gains found after five weeks were no longer present. We also found there to be no significant difference in terms of the programming practices employed while authoring programs and that students from both introductory experiences showed similar patterns in the types and frequency of syntax errors encountered (Weintrop & Wilensky, 2018). One important thing to note about this study was that the teacher who taught these classes did not employ any specific pedagogical strategies to help bridge the transition from block-based to text-based programming. ...
Conference Paper
Full-text available
The intended curriculum — the curriculum that is intended to be taught through policy, curriculum documents, or other required mandates — and the enacted curriculum — the curriculum that is actually taught in classrooms by teachers — are ideally aligned. However, often there is a chasm between the two. With computing education being relatively new to schools and teachers across many countries, we wanted to learn if a chasm existed and, if it did, how wide it is across different countries. Working as part of an international team, we created a set of templates for measuring intended curricula and a survey instrument, MEasuring TeacheR Enacted Curriculum (METRECC), to measure enacted curricula. The original pilot investigated the enacted curriculum in seven countries (with 244 teacher participants). Our research found that both visual and text-based programming languages are being used across K-12, warranting further research into potential impact on student learning and motivations. Unplugged activities are commonly used across K-12, extending into later years despite not being explicitly defined in intended curricula. Further, teachers’ motivations for programming language choice are consistent across countries and our study revealed that student-driven factors motivate selection. This initial study was followed by additional analysis with respect to teacher self-esteem that was found to differ across multiple factors such as experience in teaching CS in years and gender. We punctuate our work with the adaptation of the instrument for use in South Asia and a call to the community to consider middle- and low-income nations in future research.
... Therefore, the programmer does not need to know how the function is implemented in order to be able to work with it (Paternò and Santoro, 2019 If two blocks cannot be joined into the syntactically correct form of the expression, the programming environment prevents them from being joined. It is a prevention of syntactic errors (Hsu, Ching, 2013;Koorsse et al., 2015;Weintrop and Wilensky, 2018). The shape of graphic block is also a hint of how many connections with other blocks can be made in terms of inputs as well as outputs of the given block (Paternò and Santoro, 2019). ...
Article
Full-text available
Choosing the right way of programming can prevent learning difficulties, contribute to increasing students’ motivation to learn, and make teaching process more effective. The article is focused on assessing which way of programming, visual or textual, is appropriate for intermediate and advanced learners in the context of creating mobile applications. Three ways of programming were examined during an extracurricular programming course for teenagers aged 12-18 with previous programming experience and positive attitude to programming. The course was aimed at programming mobile applications. MIT App Inventor 2 as a visual programming tool and Android Studio with Java as a textual programming tool were chosen. Due to the gap between two programming tools, the method of transition from visual to textual programming using Java Bridge Code Generator and Java Bridge Library as mediators was implemented. The research results are based on the analysis of data obtained from participatory observations, interviews with students, questionnaires and source codes of applications created by students. The case study shows a difference in students’ performance between visual and textual programming in favour of visual programming. However, the difference in students' attitudes toward visual and textual programming was the opposite in favour of textual programming, regardless of age and learning performance. These results suggest that App Inventor visual programming environment is advantageous at the beginning of learning programming, but may be perceived as too limited and not enough motivating for intermediate and advanced students, even though programming in Android Studio professional text-based environment is too challenging for them.
... Studies have shown that during initial stages of learning a new language, whether programming [3] or natural [15], students make syntax matches between the prior language and the new language. Attempts to address these syntax transition issues have resulted in tools to support interfaces with both visual and corresponding text language for students to form analogies at the syntax level as they transition [8,13,18,46]. Interestingly enough, students assess learning syntax as more problematic than teachers [29], which might help us understand why little effort is given to the explicit explanation of syntax in many programming classrooms. ...
... Some advocate that visual languages are the best option for introducing novices to programming, while others support text-based languages as the best modality since that is what professional developers use. Thus, researchers have tried to address this topic, and they have work on evaluating the effects that the modality (block-based, text-based, and hybrid) has in the learning process [26,103,118,170,171]. Franklin et al. [53] study the differences between block-based languages (e.g., Scratch) and text-based languages (e.g., C and Java). ...
Preprint
Full-text available
Block-based environments are visual programming environments, which are becoming more and more popular because of their ease of use. The ease of use comes thanks to their intuitive graphical representation and structural metaphors (jigsaw-like puzzles) to display valid combinations of language constructs to the users. Part of the current popularity of block-based environments is thanks to Scratch. As a result they are often associated with tools for children or young learners. However, it is unclear how these types of programming environments are developed and used in general. So we conducted a systematic literature review on block-based environments by studying 152 papers published between 2014 and 2020, and a non-systematic tool review of 32 block-based environments. In particular, we provide a helpful inventory of block-based editors for end-users on different topics and domains. Likewise, we focused on identifying the main components of block-based environments, how they are engineered, and how they are used. This survey should be equally helpful for language engineering researchers and language engineers alike.
... Finally, Scratch's wide walls provided multiple pathways coders of diverse ability levels could take while learning (Resnick et al., 2009). As a result, students in our case study were able to practice assembling programs in Scratch without getting bogged down in the syntactical requirements of traditional programming languages (Weintrop & Wilensky, 2018). ...
Article
Full-text available
Background and Context: Computational Thinking (CT) is a skill all students should learn. This requires using inclusive approaches to teach CT to a wide spectrum of students. However, strategies for teaching CT to students with exceptionalities are not well studied. Objective: This study draws on lessons learned in two fourth-grade classrooms-one an inclusive general education classroom including students with and without disabilities, the other an inclusive GATE classroom including students with and without giftedness-to illustrate how CT frameworks can inform inclusive CS instruction. Method: A comparative case study design integrating content analysis and first and second cycle coding of data was used to analyze teachers' instructional strategies using a CT framework. Data included transcriptions of audio-recorded classroom lessons, field notes, and conversations with teachers and students. Findings: While each teacher used different strategies, both were effective in developing students' CT. Explicit instruction provided students receiving special education services with needed structure for the complex tasks inherent to computing. Peer feedback facilitated independent computational practice opportunities for students receiving GATE. Implications: This study highlights how inclusive instructional practices can be assessed using a CT framework and leveraged to maximize learning and access to CT curricula for learners with exceptionalities.
... Notably, the characteristics of a programming language and the design of a learning environment for programming may shape novices' practices of coding (Weintrop & Wilensky, 2018). This should be emphasized to educators, who could in turn explicitly help students foster such practices (Scheuer et al., 2017). ...
Article
Block programming has been suggested as a way of engaging young learners with the foundations of programming and computational thinking in a syntax-free manner. Indeed, syntax errors—which form one of two broad categories of errors in programming, the other one being logic errors—are omitted while block programming. However, this does not mean that errors are omitted at large in such environments. In this exploratory case study of a learning environment for early programming (Kodetu), we explored errors in block programming of middle school students ( N = 123), using log files drawn from a block-based online. Analyzing 1033 failed executions, we found that errors may be driven by either learners’ knowledge and behavior, or by the learning environment design. The rate of error types was not associated with the learners’ and contextual variables examined, with the exception of task complexity (as defined by SOLO taxonomy). Our findings highlight the importance of learning from errors and of learning environment design.
... Behavioral specification languages can be categorized into block-based, text-based, and hybrid [14]. Block-based educational development environments such as Visual Robotics Platform, based on the well-known Scratch programming language 3 , smooth the learning curve for beginners. ...
Conference Paper
Full-text available
Over the past few years, robots have found their way to the consumer market. With the rise of ubiquitous digitization, the transformative potential of robotics is immense. Yet, it is important to educate a new generation of robotics engineers on researching and engineering mobile robots and also multi-robot systems. Often, students' great intrinsic motivation to learn about this field is quickly shattered due to its inherent multifaceted challenges. These reach from the need to program robot individuals and to concert collectives to mastering the imperfections of robotics hardware. Accordingly, we present an approach to teaching robotics harnessing the means of engagement and motivation of gamification. We present a concept that builds on the tandem of simulation and hardware trials embedded into a social competitive serious game context.
... There is evidence that voice user interfaces can promote peer interactions at the age of three to four (Superti Pantoja, Diederich, Crawford, & Hourcade, 2019) and bringing them into activities aimed at promoting CT could help combine social interaction with cognitive stimulation. As interface design shapes ''what users are able to do and how they are able to do it'' (Weintrop & Wilensky, 2018), the exploration of new forms of programming seems to be an important task that could help to provide preschoolers with appropriate tools for their initial steps in CT education. ...
Article
We conducted a systematic review of empirical studies aimed at exploring robot-mediated activities to promote the development of computational thinking in preschoolers. In this study, we investigated the robots used, proposed activities, and evaluation processes. We also analyzed research contexts and the stated motivations to conduct the studies. Our review identified characteristics of the robots, such as input and output interfaces, cost, and availability. We also categorized activities considering context, modality of work, type of activities, duration, adults’ role, scaffolding, unplugged activities, explicit debugging, communication and sharing instances, and teaching knowledge from other domains. We analyzed the computational thinking evaluation process looking at types of assessments, asset concepts, and research design. This paper presents a comprehensive overview of existing research, identifies existing gaps, and provides recommendations for future studies.
Article
Full-text available
In the last few years, it has been pointed out that teaching programming is a strong strategy to develop pupils' competences in computational thinking (CT). In the Portuguese context, the curriculum changes in 2018 made programming and CT compulsory for every pupil in primary and secondary education. Nowadays, there is an information and communication technology (ICT) subject, taught by a computer science teacher in each school grade. In Portugal, to become a computer science teacher in primary and secondary education, it is compulsory to have a master's degree in computer science education. This article reports on a pedagogical activity developed with student-teachers of a Master in Teaching Informatics at the University of Lisbon. Within the activities of the master's program, we developed a cross-analysis of the core characteristics of 26 block-based and visual programming applications (apps) used to teach computational thinking and programming in school classes. In order to organize the analysis, a framework with several dimensions was developed and used by student-teachers to register the characteristics of each app. The product of this work is a comparative matrix mapping the core characteristics of each of the 26 apps that student-teachers used to select the most appropriate one for teaching programming and computational thinking according to each grade, age group and other characteristics.
Research
This study explored the potential of Virtual Reality (VR) in a computing classroom. To establish the effect VR has on creativity in the computing classroom. The thematic use of cultural tolerance to improve awareness and understanding of social justice. Existing VR education research revealed limited VR use with the context of cultural tolerance. This study proposes using a single case intervention research approach with a mixed method integrated data study design underpinned by critical pragmatism. The sample consisted of 60 secondary school students with two class teachers. Teacher participants were provided with learning materials and software to deliver the virtual reality intervention to their students participating in the study. Student participants completed pre and post questionnaires covering self-perceived understanding and ability levels of programming. A VR world analysis using VRvoice technique, an adaptation of photovoice. Finally, an in-depth interview with teacher participants. The findings discussed illustrate the potential of VR as a creative tool in computing education, developing programming skills, and highlight increased awareness of cultural tolerance through this study.
Article
Full-text available
Background and Context: The use of block-based programming environments is purported to be a good way to gently introduce novice computer programmers to computer programming. A small, but growing body of research examines the differences between block-based and text-based programming environments. Objective: Thus, the purpose of this study was to examine the overall effect of block-based versus text-based programming environments on both cognitive and affective student learning outcomes. Method: Five academic databases were searched to identify literature meeting our inclusion criteria and resulted in 13 publications with 52 effect size comparisons on both cognitive and affective outcomes. Findings: We found small effect size (g = 0.245; p = .137; with a 95% confidence interval of −0.078 to 0.567) in favor of block-based programming environments on cognitive outcomes, and a trivial effect size (g = 0.195, p = .429; with a 95% confidence interval of −0.289 to 0.678) on affective outcomes. Both effect size calculations were statistically insignificant using random effects models. The effect sizes were examined for moderating effects by education level, learning environment, and study duration. Some evidence of publication bias was detected in these data. Implications: More research is needed to examine the utility and efficacy of block-based programming environments for novice programmers. Future studies should account for hybrid programming environments using novel research methods.
Article
In this study, we attempted to curate a list of tools whose primary intent is to enable and teach children to code. From this list, we developed a framework for the classification of coding tools and reviewed current research to determine how tools are used to teach coding in elementary education. The catalog grew to over 300 specific tools intended to teach coding to children. We subsequently searched Google Scholar for studies of computational thinking in elementary or primary education. This resulted in an analysis of 161 research studies in which there was an intervention intended to teach computational thinking to young children. Through this analysis, we identified patterns in which tools have been used to teach elementary coding, to which audiences, and in what ways.
Article
Full-text available
Purpose of Review With the growing interest for STEM/STEAM, new robotic platforms are being created with different characteristics, extras, and options. There are so many diverse solutions that it is difficult for a teacher/student to choose the ideal one. This paper intends to provide an analysis of the most common robotic platforms existent on the market. The same is happening regarding robotic events all around the world, with objectives so distinctive, and with complexity from easy to very difficult. This paper also describes some of those events which occur in many countries. Recent Findings As the literature is showing, there has been a visible effort from schools and educators to teach robotics from very young ages, not only because robotics is the future, but also as a tool to teach STEM/STEAM areas. But as time progresses, the options for the right platforms also evolve making difficult to choose amongst them. Some authors opt to first choose a robotic platform and carry on from there. Others choose first a development environment and then look for which robots can be programmed from it. Summary An actual review on learning robotics is here presented, firstly showing some literature background on history and trends of robotic platforms used in education in general, the different development environments for robotics, and finishing on competitions and events. A comprehensive characterization list of robotic platforms along with robotic competitions and events is also shown.
Article
Full-text available
Computer Programming is connected to numerous areas of modern technology, as well as many university students are researching the fundamentals of it. While coding is challenging even to professional programmers at times, the novice programmers who are entering the world of coding are overwhelmed by the steep learning curves of coding languages, which often sets them back or render them 'non-interested' towards learning programming. This research studies the experiences of novice programmers who have been introduced to Virtual Reality game programming, but in an intuitive way. In this research, we introduced a visual block-based programming approach to the students to achieve their virtual reality programming. This study randomly picked a group of multimedia students (N=50) who never had programming experience or with minimal exposure to coding and recorded their experiences when they are indulged in VR programming, using CoSpaces-a Web-based visual coding tool. One of the main research questions of this study was to find out whether the block-based coding is less overwhelming to the novice learners and is there any changes in the learner's attitude towards programming after using CoSpaces. The results show a positive reaction from the learners towards visual coding concept and even many have expressed that this approach made them understand several coding basics which they weren't clear until then. This descriptive study contributes to our understanding of the connection in between coding atmosphere and discovering, illuminating the importance of shaping introductory programming experiences, especially to novice programmers.
Article
Block-based programming (BBP) environments have become increasingly commonplace computer science education. Despite a rapidly expanding ecosystem of BBP environments, text-based languages remain the dominant programming paradigm, motivating the transition from BBP to text-based programming (TBP). Support students in transitioning from BBP to TBP is an important and open design question. This work identifies 101 unique BBP environments, analyzes the 46 of them and identifies different design approaches used to support the transition to TBP. The contribution of this work is to provide a snapshot of the current state of BBP environments and how they support learners in transitioning to TBP.
Article
The participatory view of learning emphasises students' identity construction. However, identity research in the context of programming education to cultivate students' computational thinking is scarce. In this study, an instrument of computational identity with components of engagement, imagination and affiliation, was developed and validated. Convenience sampling was used to select 1066 senior primary school students studying programming to respond to the instrument, and to a programming empowerment instrument developed previously with components of meaningfulness, self‐efficacy and impact. The two instruments' factor structure was confirmed to have acceptable discriminant validity and support gender invariance. There was a positive relationship between programming empowerment and computational identity. Specifically, students' perceived meaningfulness and self‐efficacy of programming related to all aspects of computational identity. The perceived impact of programming is related only to the imaginative aspect of computational identity. The establishment of the instrument enables researchers to investigate further factors related to students' computational identity development. The results also indicate that the programming curriculum should be carefully designed so that students can realise the meaning of the activities and foster their programming self‐efficacy. This, in turn, is critical to enable these primary school students to participate in and become a member of the digital community. Practitioner notes What is already known about this topic Cultivating students' computational thinking (CT) has become an educational goal in various countries around the world. It is necessary to develop appropriate tools to assess students' CT development. Founded on a participatory view of learning, identity has been employed in different subject areas to assess students' development, but identity research in CT is scarce. What this paper adds An instrument of computational identity with components of engagement, imagination and affiliation is developed and validated with a sample of senior primary students. This study shows the importance of empowerment in developing primary students' computational identity. Students' perceived meaningfulness of programming and self‐efficacy relate to all aspects of identity, but the impact of programming only relates to the imaginative aspect of identity. Implications for practice and/or policy The curriculum for CT should be designed carefully to foster the development of students' computational identity. The curriculum should allow students to see the meaning of programming activities and how young people can make an impact by means of CT. The programming tasks should be designed at an optimal level of difficulty so that students' self‐efficacy can be fostered. What is already known about this topic Cultivating students' computational thinking (CT) has become an educational goal in various countries around the world. It is necessary to develop appropriate tools to assess students' CT development. Founded on a participatory view of learning, identity has been employed in different subject areas to assess students' development, but identity research in CT is scarce. What this paper adds An instrument of computational identity with components of engagement, imagination and affiliation is developed and validated with a sample of senior primary students. This study shows the importance of empowerment in developing primary students' computational identity. Students' perceived meaningfulness of programming and self‐efficacy relate to all aspects of identity, but the impact of programming only relates to the imaginative aspect of identity. Implications for practice and/or policy The curriculum for CT should be designed carefully to foster the development of students' computational identity. The curriculum should allow students to see the meaning of programming activities and how young people can make an impact by means of CT. The programming tasks should be designed at an optimal level of difficulty so that students' self‐efficacy can be fostered.
Article
This systematic review examined how computer science (CS) education was implemented in schools and its efficacy for developing students’ computational thinking (CT). Sixty-six papers were selected for this systematic review and analyzed for patterns in relation to the implementation of CS education in K-12 schools and its impact on the development of students’ CT skills. Although educational interventions have not always been successful in CS education, this review provides strong evidence that overall, CS education promotes the development of students’ CT in the K-12 setting while improving their creative and critical thinking skills. We recommend early access to CS education, various innovative instructional approaches to CS education and appropriate support and guidance for student learning.
Article
This study aims to comparatively determine the experiences of high school students in programming language education via Python editor or Blockly tool. The comparative case study was conducted in this study. The participants consisted of total 19 high school students with no previous experience on any programming language, 9 of them in Python editor group and 10 of them in Blockly tool group. The qualitative data obtained with a semi-structured interview at the end of 10-week programming education process and analyzed by content analysis. The findings was presented in dimensions of programming process, course outcomes, and future programming courses. In each dimension, even if common codes obtained for both groups in some themes, the effects of these codes on students differed in each group. According to results, in the programming process, students faced some difficulties and conveniences in terms of mental effort. Some situations caused the learning anxiety in students, while others did not. The students achieved positive and negative course outcomes. In addition, students' preferences whether or not to attend the future programming courses changed for various reasons. Considering the scarcity of programming education studies via Python editor and Blockly tool, the results and implications of this study will strengthen future research by providing the rich data.
Article
Full-text available
In introductory programming teaching, block-based editors have become very popular because they offer a number of strong advantages for beginning programmers: They avoid many syntax errors, can display all available instructions for visual selection and encourage experimentation with little requirement for recall. Among proficient programmers, however, text-based systems are strongly preferred due to several usability and productivity advantages for expert users. In this paper, we provide a comprehensive introduc- tion to a novel editing paradigm, frame-based editing – including design, implementation, experimentation and analysis. We describe how the design of this paradigm combines many advantages of block-based and text-based systems, then we present and discuss an implementation of such a system for a new Java-like language called Stride, including the results of several evaluation studies. The resulting editing system has clear advantages for both novices and expert programmers: It improves program representation and error avoidance for beginners and can speed up program manipulation for experts. Stride can also serve as an ideal stepping stone from block-based to text-based languages in an educational context.
Article
Full-text available
Jigsaw puzzle programming environments manipulate programs primarily by drag-and-drop. Generally these environments are based on their own special-purpose languages, meaning students must move on to another language as their programs grow. Tiled Grace is a tile-based editor for Grace, an educational programming language with a conventional textual syntax. Using Tiled Grace, programmers can move seamlessly between visualising their programs as tiles or source code, editing their programs via tiles or text, and continue on to traditional textual environments, all within the same programming language. We conducted a user experiment with Tiled Grace, and present the results of that experiment showing that users find dual views helpful.
Article
Full-text available
The focus of this research was to create and test an introductory computer science course for middle school. Titled “Foundations for Advancing Computational Thinking” (FACT), the course aims to prepare and motivate middle school learners for future engagement with algorithmic problem solving. FACT was also piloted as a seven-week course on Stanford’s OpenEdX MOOC platform for blended in-class learning. Unique aspects of FACT include balanced pedagogical designs that address the cognitive, interpersonal, and intrapersonal aspects of “deeper learning”; a focus on pedagogical strategies for mediating and assessing for transfer from block-based to text-based programming; curricular materials for remedying misperceptions of computing; and “systems of assessments” (including formative and summative quizzes and tests, directed as well as open-ended programming assignments, and a transfer test) to get a comprehensive picture of students’ deeper computational learning. Empirical investigations, accomplished over two iterations of a design-based research effort with students (aged 11–14 years) in a public school, sought to examine student understanding of algorithmic constructs, and how well students transferred this learning from Scratch to text-based languages. Changes in student perceptions of computing as a discipline were measured. Results and mixed-method analyses revealed that students in both studies (1) achieved substantial learning gains in algorithmic thinking skills, (2) were able to transfer their learning from Scratch to a text-based programming context, and (3) achieved significant growth toward a more mature understanding of computing as a discipline. Factor analyses of prior computing experience, multivariate regression analyses, and qualitative analyses of student projects and artifact-based interviews were conducted to better understand the factors affecting learning outcomes. Prior computing experiences (as measured by a pretest) and math ability were found to be strong predictors of learning outcomes.
Article
Full-text available
The Scratch system was designed to enable computing novices, without much programming expe-rience, to develop their creativity, make multimedia products, and share them with their friends and on a social media website. It can also be used to introduce programming to novices. In this initial study, we used Scratch to teach some elementary programming to young children (eight years old) in their ICT class, for eight lessons in all. Data were recorded to measure any cognitive progress of the pupils, and any affective impact that the lessons had on them. The children were soon able to write elementary programs, and moreover evidently had a lot of fun doing so. An interview with their teacher showed that some of the pupils did surprisingly well, beyond all expectations. While the cognitive progress is moderate, the main advantage to Scratch in this study seems to be that its enjoyability makes learning how to program a positive experience, contrary to the frustration and anxiety that so often seems to characterise the usual learning experience. Keywords: POP-I.A. learning to program; POP-I.B. choice of methodology; POP-II.A. novices, schoolchildren; POP-III.B. smalltalk; POP-III.C. visual languages; POP-III.D. vi-sualisation; POP-IV.A. exploratory; POP-V.B. case study; POP-VI.E.
Article
Full-text available
Scratch is a visual programming environment that allows users (primarily ages 8 to 16) to learn computer programming while working on personally meaningful projects such as animated stories and games. A key design goal of Scratch is to support self-directed learning through tinkering and collaboration with peers. This article explores how the Scratch programming language and environment support this goal.
Article
Full-text available
We are quickly passing through the historical moment when people work in front of a single computer, dominated by a small CRT and focused on tasks involving only local information. Networked computers are becoming ubiquitous and are playing increasingly significant roles in our lives and in the basic infrastructures of science, business, and social interaction. For human-computer interaction to advance in the new millennium we need to better understand the emerging dynamic of interaction in which the focus task is no longer confined to the desktop but reaches into a complex networked world of information and computer-mediated interactions. We think the theory of distributed cognition has a special role to play in understanding interactions between people and technologies, for its focus has always been on whole environments: what we really do in them and how we coordinate our activity in them. Distributed cognition provides a radical reorientation of how to think about designing and supporting human-computer interaction. As a theory it is specifically tailored to understanding interactions among people and technologies. In this article we propose distributed cognition as a new foundation for human-computer interaction, sketch an integrated research framework, and use selections from our earlier work to suggest how this framework can provide new opportunities in the design of digital work materials.
Article
Full-text available
In learning to program, many students struggle with developing algorithms, figuring out how to apply problem solving techniques in their programs, and with how to use common programming constructs. In this paper, we present a new tool that provides a possible approach to actively engage students in increasing their knowledge and skills in these areas. The tool is Alice, a 3-D interactive animation environment.
Article
Full-text available
This paper describes a model for computer programming outreach workshops aimed at second-level students (ages 15-16). Participants engage in a series of programming activities based on the Scratch visual programming language, and a very strong group-based pedagogy is followed. Participants are not required to have any prior programming experience. An empirical evaluation was undertaken to evaluate to what extent the model was successful in: (1) giving the participants a deeper understanding of what studying a computing degree and working in the computing profession entails; and (2) increasing their interest in pursuing a third-level qualification in a computer-related area.
Article
Full-text available
This article reviews research on the modality effect, the educational practice of presenting to-be-learned graphical information visually, and related textual information through an auditory mode. Meta-analytic methods were applied to 43 independent effects (39 between-subjects designs, 4 within-subjects designs). Major hypotheses regarding the instructional benefits of presenting information across modalities were supported, including the effect of two hypothesised moderators, level of element interactivity and pacing of presentation, and between certain fields of study. The strong observed modality effect under system-paced conditions must be weighed against the additional cost of developing audio-visual instructional materials.
Article
Full-text available
"Digital fluency" should mean designing, creating, and remixing, not just browsing, chatting, and interacting.
Article
Full-text available
Scratch is a "media-rich programming environment" recently developed by MIT's Media Lab that "lets you create your own animations, games, and interactive art." Although Scratch is intended to "enhance the development of technological fluency [among youths] at after-school centers in economically disadvantaged communities," we find rarkable potential in this programming environment for higher education as well.We propose Scratch as a first language for first-time programmers in introductory courses, for majors and non-majors alike. Scratch allows students to program with a mouse: programmatic constructs are represented as puzzle pieces that only fit together if "syntactically" appropriate. We argue that this environment allows students not only to master programmatic constructs before syntax but also to focus on probls of logic before syntax. We view Scratch as a gateway to languages like Java.To validate our proposal, we recently deployed Scratch for the first time in higher education via harvard Summer School's Computer Science S-1: Great Ideas in Computer Science, the summertime version of a course at harvard College. Our goal was not to improve scores but instead to improve first-time programmers' experiences. We ultimately transitioned to Java, but we first introduced programming itself via Scratch. We present in this paper the results of our trial.We find that, not only did Scratch excite students at a critical time (i.e.,, their first foray into computer science), it also familiarized the inexperienced among the with fundamentals of programming without the distraction of syntax. Moreover, when asked via surveys at term's end to reflect on how their initial experience with Scratch affected their subsequent experience with Java, most students (76%) felt that Scratch was a positive influence, particularly those without prior background. Those students (16%) who felt that Scratch was not an influence, positive or negative, all had prior programming experience. Engineering and Applied Sciences
Article
The number of students taking high school computer science classes is growing. Increasingly, these students are learning with graphical, block-based programming environments either in place of or prior to traditional text-based programming languages. Despite their growing use in formal settings, relatively little empirical work has been done to understand the impacts of using block-based programming environments in high school classrooms. In this article, we present the results of a 5-week, quasi-experimental study comparing isomorphic block-based and text-based programming environments in an introductory high school programming class. The findings from this study show students in both conditions improved their scores between pre- and postassessments; however, students in the blocks condition showed greater learning gains and a higher level of interest in future computing courses. Students in the text condition viewed their programming experience as more similar to what professional programmers do and as more effective at improving their programming ability. No difference was found between students in the two conditions with respect to confidence or enjoyment. The implications of these findings with respect to pedagogy and design are discussed, along with directions for future work.
Conference Paper
The last ten years have seen a proliferation of introductory programming environments designed for learners across the K-12 spectrum. These environments include visual block-based tools, text-based languages designed for novices, and, increasingly, hybrid environments that blend features of block-based and text-based programming. This paper presents results from a quasi-experimental study investigating the affordances of a hybrid block/text programming environment relative to comparable block-based and textual versions in an introductory high school computer science class. The analysis reveals the hybrid environment demonstrates characteristics of both ancestors while outperforming the block-based and text-based versions in certain dimensions. This paper contributes to our understanding of the design of introductory programming environments and the design challenge of creating and evaluating novel representations for learning.
Article
Blocks-based programming has become the lingua franca for introductory coding. Studies have found that experience with blocks-based programming can help beginners learn more traditional text-based languages. We explore how blocks environments improve learnability for novices by 1) favoring recognition over recall, 2) reducing cognitive load, and 3) preventing errors. Increased usability of blocks programming has led to widespread adoption within introductory programming contexts across a range of ages. Ongoing work explores further reducing barriers to programming, supporting novice programmers in expanding their programming skills, and transitioning to textual programming. New blocks frameworks are making it easier to access a variety of APIs through blocks environments, opening the doors to a greater diversity of programming domains and supporting greater experimentation for novices and professionals alike.
Conference Paper
Visual blocks languages offer many advantages to the beginner or "casual" programmer. They eliminate syntax issues, allow the user to work with logical program chunks, provide affordances such as drop-down menus, and leverage the fact that recognition is easier than recall. However, as users gain experience and start creating larger programs, they encounter two inconvenient properties of pure blocks languages: blocks take up more screen real-estate than textual languages and dragging blocks from a palette is slower than typing. This paper describes three experiments in blurring the line between blocks and textual code in GP, a new blocks language for casual programmers currently under development.
Article
How the future of general-purpose programming tools could include blocks-based structured editing, and how we should study students transitioning to text-based programming tools.
Chapter
This chapter describes working with interface metaphors. Metaphor is an integral part of language and thought. It appears not only in poetry and novels, but also in everyday speech about common matters. Metaphor is such a constant part of speech and thought that it is invisible. The characteristics of metaphor in language are the same that govern how metaphor works in an interface. Just as metaphors invisibly permeate everyday speech, they also occur throughout the interfaces that humans use and design. This chapter presents a deeper understanding of what metaphor is, and how to use it when designing an interface. It discusses some of the characteristics of metaphor in language. These characteristics provide insights on how metaphor works in an interface. The chapter also presents an example of a poorly chosen interface metaphor and how it decreases the usability of the system.
Conference Paper
Visual, block-based programming environments present an alternative way of teaching programming to novices and have proven successful in classrooms and informal learning settings. However, few studies have been able to attribute this success to specific features of the environment. In this study, we isolate the most fundamental feature of these environments, the block interface, and compare it directly to its textual counterpart. We present analysis from a study of two groups of novice programmers, one assigned to each interface, as they completed a simple programming activity. We found that while the interface did not seem to affect users' attitudes or perceived difficulty, students using the block interface spent less time off task and completed more of the activity's goals in less time.
Article
In the past decade, improvements have been made to the environments used for introductory programming education, including by the introduction of visual programming languages such as Squeak and Scratch. However, migration from these languages to text-based programming languages such as C and Java is still a problem. Hence, using the Open-Blocks framework proposed at the Massachusetts Institute of Technology, we developed a system named BlockEditor, which can translate bidirectionally between Block (the block language used here) and Java. We conducted an empirical study of this system in an introductory programming course taken by approximately 100 university students not majoring in computer science. When students were given opportunities to select the language to solve their programming assignments, we traced their selection by tracking working time with BlockEditor or Java for each individual student. The results illustrate the nature of the seamless migration from Block to Java, and show that there is great diversity in the timing and speed of migration to Java by each individual. Additionally, we found that students with low self-evaluation of their skill chose to use Block at a significantly higher rate than did students with high self-evaluation. This suggests that BlockEditor can act as scaffolding for students by promoting mixed programming between Block and Java in their migration phase.
Conference Paper
Blocks-based programming environments are becoming increasingly common in introductory programming courses, but to date, little comparative work has been done to understand if and how this approach affects students' emerging understanding of fundamental programming concepts. In an effort to understand how tools like Scratch and Blockly differ from more conventional text-based introductory programming languages with respect to conceptual understanding, we developed a set of " commutative " assessments. Each multiple-choice question on the assessment includes a short program that can be displayed in either a blocks-based or text-based form. The set of potential answers for each question includes the correct answer along with choices informed by prior research on novice programming misconceptions. In this paper we introduce the Commutative Assessment, discuss the theoretical and practical motivations for the assessment, and present findings from a study that used the assessment. The study had 90 high school students take the assessment at three points over the course of the first ten weeks of an introduction to programming course, alternating the modality (blocks vs. text) for each question over the course of the three administrations of the assessment. Our analysis reveals differences on performance between blocks-based and text-based questions as well as differences in the frequency of misconceptions based on the modality. Future work, potential implications, and limitations of these findings are also discussed.
Conference Paper
Blocks-based programming tools are becoming increasingly common in high-school introductory computer science classes. Such contexts are quite different than the younger audience and informal settings where these tools are more often used. This paper reports findings from a study looking at how high school students view blocks-based programming tools, what they identify as contributing to the perceived ease-of-use of such tools, and what they see as the most salient differences between blocks-based and text-based programming. Students report that numerous factors contribute to making blocks-based programming easy, including the natural language description of blocks, the drag-and-drop composition interaction, and the ease of browsing the language. Students also identify drawbacks to blocks-based programming compared to the conventional text-based approach, including a perceived lack of authenticity and being less powerful. These findings, along with the identified differences between blocks-based and text-based programming, contribute to our understanding of the suitability of using such tools in formal high school settings and can be used to inform the design of new, and revision of existing, introductory programming tools.
Article
Since the publication of this chapter, Jim Kaput was killed in a tragic road accident. We have all lost an energetic, visionary and dedicated colleague. Mathematics Education research has lost one of its greatest exponents, a researcher who not only understood the world of education, but knew how to change it. His theoretical work on the evolution of notational systems – much of it presented by him in this article – as well as his practical contribution, most recently through SimCalc, is living testimony to the importance and impact of his work. And we have lost a friend: a friend with a wonderful sense of humour and wit, a vibrant sense of fun, and an inspired intelligence. We will miss him.Not for the first time we are at a turning point in intellectual history. The appearances of new computational forms and literacies are pervading the social and economic lives of individuals and nations alike. Yet nowhere is this upheaval correspondingly represented in educational systems, in classrooms, or in school curricula. As far as mathematics is concerned, the massive changes to mathematics that characterize the late twentieth century—in terms of the way it is done, and what counts as mathematics—are almost invisible in the classrooms of our schools and, to only a slightly lesser extent, our universities. The real changes are not technical: they are cultural. Understanding them (and why some things change quickly and others change slowly) is a question of the social relations among people, not among things. Nevertheless, there are important ways in which computational technologies are different from those that preceded them, and in trying to assess the actual and potential contribution of these technologies to education, it will help to view them in a historical light.
Article
This paper describes how Alice 2.0 is being used in an introductory programming course, the first in a three course sequence that meets the description of the object-oriented sequence described in the CC2001 report. The modifications to the syllabi to accommodate an Alice-Java-Java sequence are described.. Issues caused by using Alice for an introduction programming in the first course for both computing majors and liberal studies students are explored. Retention data and percentage of women enrolled when using Alice for the first semester is compared to data for C++.
Conference Paper
Alice is a novel programming environment for building 3D virtual worlds. The graphical programming interface of Alice allows beginning programmers to learn about concepts such as object-oriented design and recursion without the need to struggle with syntax errors. This paper discusses the opinions of Alice from 84 students who took an introductory programming course (CS1) that covered both Alice and Java in the same term. Fifty students (59.5%) responded on the survey that the prior experience with Alice helped them to learn Java later in the term. Fifty-six students (66.7%) recommended continued use of Alice in the course although many suggested reducing the amount of time spent on Alice. While these numbers could be interpreted as a positive result, they have actually discouraged our department from continuing to use Alice in CS1. The number of students who were not sure that Alice was helping with their understanding of Java later in the term was simply too great to justify continued coverage of Alice in the course.
Article
Cognitive science normally takes the individual agent as its unit of analysis. In many human endeavors, however, the outcomes of interest are not determined entirely by the information processing properties of individuals. Nor can they be inferred from the properties of the individual agents, alone, no matter how detailed the knowledge of the properties of those individuals may be. In commercial aviation, for example, the successful completion of a flight is produced by a system that typically includes two or more pilots interacting with each other and with a suite of technological devices. This article presents a theoretical framework that takes a distributed, socio-technical system rather than an individual mind as its primary unit of analysis. This framework is explicitly cognitive in that it is concerned with how information is represented and how representations are transformed and propagated in the performance of tasks. An analysis of a memory task in the cockpit of a commercial airliner shows how the cognitive properties of such distributed systems can differ radically from the cognitive properties of the individuals who inhabit them.
Article
Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2007. This electronic version was submitted by the student author. The certified thesis is available in the Institute Archives and Special Collections. Includes bibliographical references (leaves 60-61). Graphical programming systems have been built to lower the threshold to programming for beginners. However, because these systems were designed to make programming more accessible to novices, they were developed with narrower intentions for their users and applications. For example, in StarLogo TNG, a graphical block programming environment, users may create games and simulations, but they cannot use this same system to create programs that can automate their computer processes, like the text-based scripting system AppleScript. Application developers can create their own programming systems, but doing so can take a significant amount of time to design and implement. This thesis describes an extendable framework called OpenBlocks that enables application developers to build and iterate their own graphical block programming systems by specifying a single XML file. Application developers can focus more on the design of their systems instead of oil the details of implementation. The design and implementation of OpenBlocks are described, along with a user study conducted to test its usability and extendability. by Ricarose Vallarta Roque. M.Eng.
Conference Paper
Alice is a software environment in which students learn programming concepts by making animated movies and interactive applications. Monmouth University's Computer Science and Software Engineering departments each introduced the use of Alice in fall 2005 in two newly-created courses. The courses serve as freshman overviews of their respective disciplines and also, using Alice, introduce students to object-oriented programming ideas. Previously the first computer science course for majors in these programs was a traditional C++ Programming I course, which had a success rate of less than 50. This course was retained, but became the second course in these majors. From fall 2003 to spring 2007, 106 students enrolled in the traditional Programming I course in C++. Of these, 37 had previously taken one of the new overview courses including Alice; the remaining students had not. Among students who had not taken either new course, the success rate was 46.4%; among those who had, the success rate was 70.3%. The probability of observing these results if the new introductory courses using Alice had no effect would be less than 0.006. We have concluded that exposure to Alice in these courses has significantly increased students' probability of success in the traditional Programming I course.
Should your 8-year-old learn coding
  • C Duncan
  • T Bell
  • S Tanimoto
C. Duncan, T. Bell, S. Tanimoto, Should your 8-year-old learn coding? in: Proc. 9th Workshop Prim. Second. Comput. Educ., ACM, New York, NY, USA, 2014, pp. 60-69.
Towards a theory of symbol
  • J J Kaput
J.J. Kaput, Towards a theory of symbol, in: C. Janvier (Ed.), Probl. Represent. Teach. Learn. Math., Lawrence Erlbaum Associates, Hillsdale, N.J., 1987, p. 159.
Restructuring change, interpreting changes: The deltatick modeling and analysis toolkit
  • M H Wilkerson-Jerde
  • U Wilensky
M.H. Wilkerson-Jerde, U. Wilensky, Restructuring change, interpreting changes: The deltatick modeling and analysis toolkit, in: J. Clayson, I. Kalas (Eds.), Proc. Constr. 2010 Conf. Paris, France, 2010.
NetTango: A mash-up of netlogo and tern
  • M S Horn
  • U Wilensky
M.S. Horn, U. Wilensky, NetTango: A mash-up of netlogo and tern, in: Moher, T. (chair), Pinkard, N. (discussant), Syst. Collide Chall. Oppor. Learn. Technol. Mashups, Vancouver, British Columbia, 2012.
RoboBuilder: A program-to-play constructionist video game
  • D Weintrop
  • U Wilensky
D. Weintrop, U. Wilensky, RoboBuilder: A program-to-play constructionist video game, in: C. Kynigos, J. Clayson, N. Yiannoutsou (Eds.), Proc. Constr. 2012
Pencil code: block code for a text world
  • D Bau
  • D A Bau
  • M Dawson
  • C S Pickens
D. Bau, D.A. Bau, M. Dawson, C.S. Pickens, Pencil code: block code for a text world, in: Proc. 14th Int. Conf. Interact. Des. Child., ACM, New York, NY, USA, 2015, pp. 445-448.
From blocks to text and back: Programming patterns in a dual-modality environment
  • D Weintrop
  • N Holbert
D. Weintrop, N. Holbert, From blocks to text and back: Programming patterns in a dual-modality environment, in: Proc. 48th ACM Tech. Symp. Comput. Sci. Educ., ACM, New York, NY, USA, 2017.
Frame-based editing: easing the transition from blocks to text-based programming
  • M Kölling
  • N C C Brown
  • A Altadmri
M. Kölling, N.C.C. Brown, A. Altadmri, Frame-based editing: easing the transition from blocks to text-based programming, in: Proc. Workshop Prim. Second. Comput. Educ., ACM, New York, NY, USA, 2015, pp. 29-38.
The challenges of studying blocks-based programming environments
  • D Weintrop
  • U Wilensky
D. Weintrop, U. Wilensky, The challenges of studying blocks-based programming environments, in: 2015 IEEE Blocks Workshop Blocks Beyond, 2015, pp. 5-7.
  • O Meerbaum-Salant
  • M Armoni
  • M M Ben-Ari
O. Meerbaum-Salant, M. Armoni, M.M. Ben-Ari, Learning computer science concepts with Scratch, in: Proc. Sixth Int. Workshop Comput. Educ. Res., 2010, pp. 69-76.
Habits of programming in scratch
  • O Meerbaum-Salant
  • M Armoni
  • M Ben-Ari
O. Meerbaum-Salant, M. Armoni, M. Ben-Ari, Habits of programming in scratch, in: Proc. 16th Annu. Jt. Conf. Innov. Technol. Comput. Sci. Educ., ACM, Darmstadt, Germany, 2011, pp. 168-172.
Using upper-elementary student performance to understand conceptual sequencing in a blocks-based curriculum
  • D Franklin
  • G Skifstad
  • R Rolock
  • I Mehrotra
  • V Ding
  • A Hansen
  • D Weintrop
  • D Harlow
D. Franklin, G. Skifstad, R. Rolock, I. Mehrotra, V. Ding, A. Hansen, D. Weintrop, D. Harlow, Using upper-elementary student performance to understand conceptual sequencing in a blocks-based curriculum, in: Proc. 2017 ACM SIGCSE Tech. Symp. Comput. Sci. Educ., ACM, New York, NY, USA, 2017, pp. 231-236.
Evaluating the effectiveness of a new instructional approach
  • B Moskal
  • D Lurie
  • S Cooper
B. Moskal, D. Lurie, S. Cooper, Evaluating the effectiveness of a new instructional approach, in: Proc. 35th SIGCSE Tech. Symp. Comput. Sci. Educ., 2004, pp. 75-79.
Lessons in combining block-based and textual programming
  • M Homer
  • J Noble
M. Homer, J. Noble, Lessons in combining block-based and textual programming, J. Vis. Lang. Sentient Syst. 3 (2017) 22-39. http://dx.doi.org/10.18293/ VLSS2017.