Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Scope
Method
Research Questions
Filtering and Data Analysis
Overview of Introductory Programming Research
Summary
Design Tools
Assessment Design
Assessment Analysis
Limitations
Discussion and Conclusions
References
All Topics
Computer Science
Software

Introductory Programming: A Systematic Literature Review

Profile image of Michael 'Adrir' ScottMichael 'Adrir' Scott

2018, Proceedings Companion of the 23rd Annual ACM Conference on Innovation and Technology in Computer Science Education

https://doi.org/10.1145/3293881.3295779
visibility

…

description

52 pages

link

1 file

Abstract

As computing becomes a mainstream discipline embedded in the school curriculum and acts as an enabler for an increasing range of academic disciplines in higher education, the literature on introductory programming is growing. Although there have been several reviews that focus on specific aspects of introductory programming, there has been no broad overview of the literature exploring recent trends across the breadth of introductory programming. This paper is the report of an ITiCSE working group that conducted a systematic review in order to gain an overview of the introductory programming literature. Partitioning the literature into papers addressing the student, teaching, the curriculum, and assessment, we explore trends, highlight advances in knowledge over the past 15 years, and indicate possible directions for future research.

Related papers

Curriculum, Teaching and Learning, and Assessments for Introductory Programming Course
DR. ADNAN ABID

IEEE Access

Learning to program involves acquisition of various skills including problem solving, fundamental design techniques as well as critical thinking. Generally, most of the novice programmers struggle to develop all these important skill. The research community has addressed the problem in many different ways while involving improvisations in curriculum, pedagogical methods, cognitive aspects, supporting tools, and in designing assessments. This research aims to analyze and synthesize the existing literature in the aforementioned areas. Research articles pertaining to the area of Introductory Programming Courses (IPC) have been found using appropriate search queries, while nearly 60 research articles, published in last ten years, have been carefully selected by employing a systematic filtering process. The scope of this work only covers the research conducted for IPC in higher education. Main findings of this study show that ''solution proposal'' and ''evaluation research'' have been reported as two main research types adopted by these studies. Moreover, pedagogy, language choice and students' performance analysis are the most frequently addressed aspects of IPC; whereas, curriculum contents, assessment design, and teaching/learning through tools have appeared as less addressed aspects of IPC. Furthermore, a taxonomy of IPC has been presented based on the studied literature. Lastly, general considerations and future research directions have been presented for the practitioners and researchers in this area.

View PDFchevron_right
A comparison of different approaches to the introductory programming course
Myles McNally

Proceedings of the 8th …, 2006

Over the last few years the number of visual and nontraditional programming environments to support the introductory programming course has greatly increased. While in the past, instructors of the introductory programming course simply had to select a compiler (and possibly a development environment), today they face a plethora of choices. This panel will present four such popular visual/non-traditional programming environments.

View PDFchevron_right
An ITiCSE 2004 Working Group: A Study of the Programming Knowledge of First-Year CS Students
Raymond Lister

www-staff.it.uts.edu.au

Despite our best efforts, many students are still challenged by programming. A 2001 ITiCSE working group (the “McCracken group”) assessed the programming ability of a large population of students from eight universities, in the United States and four other countries [McCracken, 2001]. Each author tested his or her own students from a common set of programming problems. The students at each institution were required to write a program to solve one of the problems. Most students at all the institutions performed much more ...

View PDFchevron_right
An integrated approach to teaching introductory programming
Wayne Pullan

2013 Second International Conference on E-Learning and E-Technologies in Education (ICEEE), 2013

Java Programming Laboratory (JPL) is a cloud based, integrated learning environment used for teaching introductory Java programming at Griffith University, Australia. JPL incorporates a number of features found in other successful programming learning environments and builds upon them with a range of innovative features. Learning to program is a threshold concept area for ICT students and success in this endeavour is paramount for student progression and retention. JPL provides a database that tracks individual students' successes and progression through scaffolded programming exercises and assessment items and gives students immediate feedback on their use of programming language syntax and correctness of problem solutions. A data querying and visualisation facility allows analysis of the database to provide real-time performance indicators from the overall course / problem level down to the individual student / specific problem level. Programming instructors and curriculum designers will find that this facility allows a responsive approach to student engagement, assistance and progression; as well as course problem tuning in a just-in-time manner.

View PDFchevron_right
Studies and proposals about initial programming learning
Anabela Gomes

2010

The difficulties many novices feel to learn programming are well known. They don't seem directly related to the programming paradigm or language used. We present some studies and proposals that may give some contributions to help students and reduce their difficulties in programming learning. We think it is crucial to get an in depth knowledge about the main factors that cause this problem. As the problem is complex, we used a triangulation of methods on a series of studies that we have carried through in recent years. The idea was to accumulate evidence and compare it with results of other studies published in literature. We joined and compared multiple sources of data and collated the methods in order to corroborate some conclusions. From the drawn conclusions concerning the main difficulties, we propose a set of suitable educative practices that, in our perspective, can help students learn, minimizing their programming difficulties.

View PDFchevron_right
Teaching Introductory Programming: A Quantitative Evaluation of Different Approaches
Robert Macredie

Teaching programming to beginners is a complex task. In this paper, the effects of three factors -choice of programming language, problem-solving training and the use of formative assessment -on learning to program were investigated. The study adopted an iterative methodological approach carried out across four consecutive years. To evaluate the effects of each factor (implemented as a single change in each iteration) on students' learning performance, the study used quantitative, objective metrics. The findings revealed that using a syntactically-simple language (Python) instead of a more complex one (Java) facilitated students' learning of programming concepts. Moreover, teaching problem-solving before programming yielded significant improvements in students' performance. These two factors were found to have variable effects on the acquisition of basic programming concepts. Finally, it was observed that effective formative feedback in the context of introductory programming depends on multiple parameters. The paper discusses the implications of these findings, identifies avenues for further research and argues for the importance of studies in computer science education anchored on sound research methodologies to produce generalizable results.

View PDFchevron_right
From theory to practice: implementing the CC2001's introductory programming sequence
Ray Lang

33rd Annual Frontiers in Education, 2003. FIE 2003.

Xavier University of LA's Computer Sciences and Computer Engineering (CSCE) Department recently assessed its computer science program using both its own assessment data and the Computing Curricula 2001 (CC2001) recommendations. This assessment resulted in changes to Xavier's computer science curriculum. Specifically, the department e xamined its introductory programming sequence and developed a detailed schedule that addressed both the department's needs and the curriculum recommendations. The previous ACM recommended curriculum suggested a two-course introductory programming sequence; however, since a large number of Xavier's incoming students have no programming experience, the CSCE Department had been offering a threecourse introductory programming sequence. This threecourse sequence provided time for the faculty to discuss the recommended topics in the detail necessary for our students. The CC2001 recommendations realized that a three-course sequence is more appropriate for the topic coverage needed and provided a curriculum that contained this type of introduction. The Xavier CSCE faculty considered these recommendations and used its experience in working with a three-course introductory sequence to develop a new sequence that includes the topics suggested in the new curriculum recommendations while considering many of the realities of teaching such a sequence to undergraduates with no programming experience. This paper discusses the process used by the department in making the curriculum changes, particularly focusing on the introductory programming sequence. The paper provides the rationale used in developing the course sequence and the specific topics addressed in these courses.

View PDFchevron_right
New challenges in teaching introductory programming courses: a case study
Osvaldo Pacheco

34th Annual Frontiers in Education, 2004. FIE 2004., 2004

The Department of Educational Sciences and the Department of Electronic & Telecommunications at the University of Aveiro (Portugal) have been working together with the Department of Computer & Information Sciences at the University of Strathclyde (UK), with the aim of improving the teaching quality of introductory programming courses and, indirectly, the academic success of their students. Over the past two years, data has been collected through interviews and questionnaires, to better understand the organization of the different courses and approaches to teaching. The present paper discusses how the organization of introductory programming courses in each institution reflects the teaching philosophy of the members of staff and also how course organization and teaching strategy relate to the students' attitudes to learning and their motivation for course involvement.

View PDFchevron_right

References (745)

  1. Kalle Aaltonen, Petri Ihantola, and Otto Seppälä. 2010. Mutation analy- sis vs. code coverage in automated assessment of students' testing skills. In Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion (OOPSLA '10). ACM, New York, NY, USA, 153-160. https://doi.org/10.1145/ 1869542.1869567
  2. Samy S. Abu Naser. 2009. Evaluating the effectiveness of the CPP-Tutor, an Intelligent Tutoring System for students learning to program in C++. Journal of Applied Sciences Research 5, 1 (2009), 109-114.
  3. Michał Adamaszek, Piotr Chrzaçstowski-Wachtel, and Anna Niewiarowska. 2008. VIPER a student-friendly visual interpreter of Pascal. In Informatics Education -Supporting Computational Thinking, Roland T. Mittermeir and Maciej M. Sysło (Eds.). Springer, Berlin, Heidelberg, 192-203. https://doi.org/10. 1007/978-3-540-69924-8_18
  4. Abejide Ade-Ibijola, Sigrid Ewert, and Ian Sanders. 2014. Abstracting and narrat- ing novice programs using regular expressions. In Proceedings of the Southern African Institute for Computer Scientist and Information Technologists Annual Conference 2014 on SAICSIT 2014 Empowered by Technology (SAICSIT '14).
  5. ACM, New York, NY, USA, Article 19, 19:19-19:28 pages. https://doi.org/10. 1145/2664591.2664601
  6. Achla Agarwal, Krishna K. Agarwal, Leslie Fife, and M. Emre Celebi. 2016. Raptor and Visual Logic©: a comparison of flowcharting tools for CS0. J. Comput. Sci. Coll. 31, 4 (2016), 36-41. http://dl.acm.org/citation.cfm?id=2904127.2904132
  7. Alireza Ahadi, Raymond Lister, Shahil Lal, Juho Leinonen, and Arto Hellas. 2017. Performance and consistency in learning to program. In Proceedings of the Nineteenth Australasian Computing Education Conference (ACE '17). ACM, New York, NY, USA, 11-16. https://doi.org/10.1145/3013499.3013503
  8. Nova Ahmed, Arman Kamal, Adnan Nuruddin, and Syed Tanveer Jishan. 2016. My code in my native tone: Cha Script. In Proceedings of the Eighth International Conference on Information and Communication Technologies and Development (ICTD '16). ACM, New York, NY, USA, Article 28, 28:1- 28:4 pages. https://doi.org/10.1145/2909609.2909611
  9. Tuukka Ahoniemi and Essi Lahtinen. 2007. Visualizations in preparing for programming exercise sessions. Electronic Notes in Theoretical Computer Science 178 (2007), 137-144. https://doi.org/10.1016/j.entcs.2007.01.043
  10. T. C. Ahren. 2005. Using online annotation software to provide timely feed- back in an introductory programming course. In IEEE Frontiers in Education Conference (FIE '05). IEEE, T2H-1. https://doi.org/10.1109/FIE.2005.1611917
  11. Nouf M. Al-Barakati and Arwa Y. Al-Aama. 2009. The effect of visualizing roles of variables on student performance in an introductory programming course. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 228-232. https://doi.org/10.1145/1562877.1562949
  12. Ahmad Al-Jarrah and Enrico Pontelli. 2014. "AliCe-ViLlagE" Alice as a Collabora- tive Virtual Learning Environment. In IEEE Frontiers in Education Conference (FIE '14). IEEE, 1-9. https://doi.org/10.1109/FIE.2014.7044089
  13. Ali Alammary, Angela Carbone, and Judy Sheard. 2012. Implementation of a smart lab for teachers of novice programmers. In Proceedings of the Fourteenth Australasian Computing Education Conference -Volume 123 (ACE '12). Aus- tralian Computer Society, Inc., Darlinghurst, Australia, Australia, 121-130. http://dl.acm.org/citation.cfm?id=2483716.2483731
  14. Ahmed S. Alardawi and Agil M. Agil. 2015. Novice comprehension of object-oriented OO programs: an empirical study. In 2015 World Congress on Information Technology and Computer Applications (WCITCA). IEEE, 1- 4. https://doi.org/10.1109/WCITCA.2015.7367057
  15. Veljko Aleksić and Mirjana Ivanović. 2016. Introductory programming subject in European higher education. Informatics in Education 15, 2 (2016), 163-182. https://doi.org/10.15388/infedu.2016.09
  16. José Luis Fernández Alemán, Dominic Palmer-Brown, and Chrisina Draganova. 2010. Evaluating student response driven feedback in a programming course. In 2010 10th IEEE International Conference on Advanced Learning Technologies. IEEE, 279-283. https://doi.org/10.1109/ICALT.2010.82
  17. Laura K. Alford, Mary Lou Dorf, and Valeria Bertacco. 2017. Student perceptions of abilities and learning environment in large introductory computer programming courses. In ASEE Annual Conference and Exposition, Conference Proceedings, Vol. 2017-June. ASEE.
  18. Carl Alphonce and Blake Martin. 2005. Green: a pedagogically customizable round-tripping UML class diagram Eclipse plug-in. In Proceedings of the 2005 OOPSLA Workshop on Eclipse Technology eXchange (eclipse '05). ACM, New York, NY, USA, 115-119. https://doi.org/10.1145/1117696.1117720
  19. Carl Alphonce and Phil Ventura. 2003. Using graphics to support the teaching of fundamental object-oriented principles in CS1. In Companion of the 18th Annual ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages, and Applications (OOPSLA '03). ACM, New York, NY, USA, 156-161. https://doi.org/10.1145/949344.949391
  20. Fatima AlShamsi and Ashraf Elnagar. 2009. JLearn-DG: Java learning system using dependence graphs. In Proceedings of the 11th International Conference on Information Integration and Web-based Applications &Amp; Services (iiWAS '09). ACM, New York, NY, USA, 633-637. https://doi.org/10. 1145/1806338.1806458
  21. Maria Altebarmakian, Richard Alterman, Anna Yatskar, Kendall Harsch, and Antonella DiLillo. 2016. The microgenetic analysis of staged peer collabora- tion for introductory programming. In IEEE Frontiers in Education Conference (FIE '16). IEEE, 1-8. https://doi.org/10.1109/FIE.2016.7757613
  22. Raad A. Alturki. 2016. Measuring and improving student performance in an introductory programming course. Informatics in Education 15, 2 (2016), 183- 204. https://doi.org/10.15388/infedu.2016.10
  23. Omar AlZoubi, Davide Fossati, Barbara Di Eugenio, Nick Green, Mehrdad Al- izadeh, and Rachel Harsley. 2015. A hybrid model for teaching recursion. In Proceedings of the 16th Annual Conference on Information Technology Education (SIGITE '15). ACM, New York, NY, USA, 65-70. https://doi.org/10. 1145/2808006.2808030
  24. Milan Amaratunga, Gayan Wickramasinghe, Milinda Deepal, Oshani Perera, Dilshan De Silva, and Samantha Rajapakse. 2013. An interactive programming assistance tool (iPAT) for instructors and novice programmers. In 2013 8th International Conference on Computer Science & Education. IEEE, 680-684. https://doi.org/10.1109/ICCSE.2013.6553995
  25. Ana Paula L. Ambrósio and Fábio M. Costa. 2010. Evaluating the impact of PBL and tablet PCs in an algorithms and computer programming course. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). ACM, New York, NY, USA, 495-499. https://doi.org/ 10.1145/1734263.1734431
  26. Lorin W Anderson, David R Krathwohl, Peter W Airasian, Kathleen A Cruik- shank, Richard E Mayer, Paul R Pintrich, James Raths, and Merlin C Wit- trock. 2001. A Taxonomy for Learning, Teaching, and Assessing: A Revision of Bloom's Taxonomy of Educational Objectives (abridged ed.). Longman, White Plains, NY.
  27. Ruth E. Anderson, Michael D. Ernst, Robert Ordóñez, Paul Pham, and Ben Tribelhorn. 2015. A data programming CS1 course. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 150-155. https://doi.org/10.1145/2676723.2677309
  28. Subashini Annamalai and Sobihatun Nur Abdul Salam. 2017. A multimedia ap- proach towards learning C programming: a discussion from novice learners' per- spective. Journal of Telecommunication, Electronic and Computer Engineering 9, 2-12 (2017), 99-103.
  29. D. F. Ninan S. A. Akinboro H. Abimbola Soriyan Anuoluwapo Ajayi, Emmanuel A. Olajubu. 2010. Development and testing of a graphical FORTRAN learn- ing tool for novice programmers. Interdisciplinary Journal of Information, Knowledge, and Management 5 (2010), 277-291. https://doi.org/10.28945/1176 [29] Masayuki Arai and Tomomi Yamazaki. 2006. Design of a learning support system to aid novice programmers in obtaining the capability of tracing. In Proceedings of the Sixth International Conference on Advanced Learning Technologies (ICALT '06). IEEE, 396-397.
  30. Eliane Araujo, Matheus Gaudencio, Dalton Serey, and Jorge Figueiredo. 2016. Ap- plying spectrum-based fault localization on novice's programs. In IEEE Frontiers in Education Conference (FIE '16). IEEE, 1-8. https://doi.org/10.1109/FIE.2016. 7757727
  31. Glen Archer, Briana Bettin, Leonard Bohmann, Allison Carter, Christopher Cischke, Linda M Ott, and Leo Ureel. 2017. The impact of placement strategies on the success of students in introductory computer science. In IEEE Frontiers in Education Conference (FIE '17). IEEE, 1-9. https://doi.org/10.1109/FIE.2017. 8190526
  32. Hazleen Aris. 2015. Improving students performance in introductory pro- gramming subject: a case study. In 10th International Conference on Computer Science & Education (ICCSE '15). IEEE, 657-662. https://doi.org/10.1109/ICCSE. 2015.7250328
  33. Muhammad Ateeq, Hina Habib, Adnan Umer, and Muzammil Ul Rehman. 2014. C++ or Python? Which one to begin with: a learner's perspective. In International Conference on Teaching and Learning in Computing and Engineering (LaTiCE '14). IEEE, 64-69. https://doi.org/10.1109/LaTiCE.2014.20
  34. Nikolaos Avouris, Stefanos Kaxiras, Odysseas Koufopavlou, Kyriakos Sgarbas, and Polyxeni Stathopoulou. 2010. Teaching introduction to computing through a project-based collaborative learning approach. In 2010 14th Panhellenic Conference on Informatics. IEEE, 237-241. https://doi.org/10.1109/PCI.2010.13
  35. John Aycock, Etienne Pitout, and Sarah Storteboom. 2015. A game engine in pure Python for CS1: design, experience, and limits. In Proceedings of the 2015 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '15). ACM, New York, NY, USA, 93-98. https://doi.org/10. 1145/2729094.2742590
  36. Mewati Ayub, Hapnes Toba, Steven Yong, and Maresha C. Wijanto. 2017. Mod- elling students' activities in programming subjects through educational data mining. Global Journal of Engineering Education 19, 3 (2017), 249-255.
  37. David Azcona and Alan F. Smeaton. 2017. Targeting at-risk students using engagement and effort predictors in an introductory computer programming course. In Data Driven Approaches in Digital Education. Springer International Publishing, 361-366. https://doi.org/10.1007/978-3-319-66610-5_27
  38. Shahdatunnaim Azmi, Noorminshah A Iahad, and Norasnita Ahmad. 2016. Attracting students' engagement in programming courses with gamification. In IEEE Conference on e-Learning, e-Management and e-Services (IC3e '16). 112-115. https://doi.org/10.1109/IC3e.2016.8009050
  39. Monica Babes-Vroman, Isabel Juniewicz, Bruno Lucarelli, Nicole Fox, Thu Nguyen, Andrew Tjang, Georgiana Haldeman, Ashni Mehta, and Risham Chok- shi. 2017. Exploring gender diversity in CS at a large public R1 research university. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 51-56. https://doi.org/10.1145/3017680.3017773
  40. Suzan Badri, James Denholm-Price, and James Orwell. 2011. Layout for learning: designing an interface for students learning to program. In Proceedings of the 3rd International Conference on Computer Supported Education (CSEDU '11), Vol. 1. INSTICC, SciTePress, 324-332. https://doi.org/10.5220/0003346403240332
  41. Yu Bai, Liqian Chen, Gang Yin, Xinjun Mao, Ye Deng, Tao Wang, Yao Lu, and Huaimin Wang. 2017. Quantitative analysis of learning data in a programming course. In Database Systems for Advanced Applications. Springer International Publishing, 436-441. https://doi.org/10.1007/978-3-319-55705-2_37
  42. Bridget Baird and Christine Chung. 2010. Expanding CS1: applications across the liberal arts. J. Comput. Sci. Coll. 25, 6 (2010), 47-54. http://dl.acm.org/ citation.cfm?id=1791129.1791139
  43. Olle Bälter and Duane A. Bailey. 2010. Enjoying Python, processing, and Java in CS1. ACM Inroads 1, 4 (2010), 28-32. https://doi.org/10.1145/1869746.1869758
  44. Albert Bandura. 1962. Social learning through imitation. In Nebraska Symposium on Motivation. Univer. Nebraska Press, Oxford, England, 211-274.
  45. Mousumi Banerjee, Michelle Capozzoli, Laura McSweeney, and Debajyoti Sinha. 1999. Beyond kappa: a review of interrater agreement measures. The Canadian Journal of Statistics / La Revue Canadienne de Statistique 27, 1 (1999), 3-23. http://www.jstor.org/stable/3315487
  46. Lecia J. Barker, Charlie McDowell, and Kimberly Kalahar. 2009. Exploring factors that influence computer science introductory course students to persist in the major. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 153-157. https: //doi.org/10.1145/1508865.1508923
  47. Ian Barland. 2008. Some methods for teaching functions first using Java. In Proceedings of the 46th Annual Southeast Regional Conference on XX (ACM-SE 46). ACM, New York, NY, USA, 256-259. https://doi.org/10.1145/ 1593105.1593172
  48. Glenda Barlow-Jones and Duan van der Westhuizen. 2017. Problem solving as a predictor of programming performance. In Communications in Computer and Information Science. Springer International Publishing, 209-216. https: //doi.org/10.1007/978-3-319-69670-6_14
  49. Tiffany Barnes, Eve Powell, Amanda Chaffin, and Heather Lipford. 2008. Game2Learn: improving the motivation of CS1 students. In Proceedings of the 3rd International Conference on Game Development in Computer Science Education (GDCSE '08). ACM, New York, NY, USA, 1-5. https://doi.org/10.1145/ 1463673.1463674
  50. Valerie Barr and Deborah Trytten. 2016. Using turing's craft codelab to support CS1 students as they learn to program. ACM Inroads 7, 2 (2016), 67-75. https: //doi.org/10.1145/2903724
  51. Jordan Barria-Pineda, Julio Guerra, Yun Huang, and Peter Brusilovsky. 2017. Concept-level knowledge visualization for supporting self-regulated learning. In Proceedings of the 22nd International Conference on Intelligent User Interfaces Companion (IUI '17 Companion). ACM, New York, NY, USA, 141-144. https: //doi.org/10.1145/3030024.3038262
  52. João Paulo Barros, Luís Estevens, Rui Dias, Rui Pais, and Elisabete Soeiro. 2003. Using lab exams to ensure programming practice in an introductory program- ming course. In Proceedings of the 8th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '03). ACM, New York, NY, USA, 16-20. https://doi.org/10.1145/961511.961519
  53. Jessica D. Bayliss and Sean Strout. 2006. Games as a "flavor" of CS1. In Proceedings of the 37th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '06). ACM, New York, NY, USA, 500-504. https://doi.org/ 10.1145/1121341.1121498
  54. Jennifer Bayzick, Bradley Askins, Sharon Kalafut, and Michael Spear. 2013. Read- ing mobile games throughout the curriculum. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 209-214. https://doi.org/10.1145/2445196.2445264
  55. Leland L. Beck, Alexander W. Chizhik, and Amy C. McElroy. 2005. Coop- erative learning techniques in CS1: design and experimental evaluation. In Proceedings of the 36th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '05). ACM, New York, NY, USA, 470-474. https://doi.org/ 10.1145/1047344.1047495
  56. Brett A. Becker. 2016. An effective approach to enhancing compiler error mes- sages. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 126-131. https: //doi.org/10.1145/2839509.2844584
  57. Brett A. Becker. 2016. A new metric to quantify repeated compiler errors for novice programmers. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 296-301. https://doi.org/10.1145/2899415.2899463
  58. Brett A. Becker, Graham Glanville, Ricardo Iwashima, Claire McDonnell, Kyle Goslin, and Catherine Mooney. 2016. Effective compiler error message enhance- ment for novice programming students. Computer Science Education 26, 2-3 (2016), 148-175. https://doi.org/10.1080/08993408.2016.1225464
  59. Mordechai Ben-Ari. 2001. Constructivism in computer science education. Journal of Computers in Mathematics and Science Teaching 20, 1 (2001), 45- 73.
  60. Mordechai Ben-Ari, Roman Bednarik, Ronit Ben-Bassat Levy, Gil Ebel, Andrés Moreno, Niko Myller, and Erkki Sutinen. 2011. A decade of research and development on program animation: the Jeliot experience. Journal of Visual Languages & Computing 22 (2011), 375-384. https://doi.org/10.1016/j.jvlc.2011. 04.004
  61. Jens Bennedsen and Michael E. Caspersen. 2004. Programming in context: a model-first approach to CS1. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 477-481. https://doi.org/10.1145/971300.971461
  62. Jens Bennedsen and Michael E. Caspersen. 2005. Revealing the programming process. In Proceedings of the 36th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '05). ACM, New York, NY, USA, 186-190. https: //doi.org/10.1145/1047344.1047413
  63. Jens Bennedsen and Michael E. Caspersen. 2006. Abstraction ability as an indicator of success for learning object-oriented programming? SIGCSE Bull. 38, 2 (2006), 39-43. https://doi.org/10.1145/1138403.1138430
  64. Jens Bennedsen and Michael E. Caspersen. 2007. Failure rates in introductory programming. SIGCSE Bull. 39, 2 (2007), 32-36. https://doi.org/10.1145/1272848. 1272879
  65. Jens Bennedsen and Carsten Schulte. 2007. What does "objects-first" mean?: An international study of teachers' perceptions of objects-first. In Proceedings of the Seventh Baltic Sea Conference on Computing Education Research -Volume 88 (Koli Calling '07). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 21-29. http://dl.acm.org/citation.cfm?id=2449323.2449327
  66. Jens Bennedsen and Carsten Schulte. 2010. BlueJ visual debugger for learning the execution of object-oriented programs? Trans. Comput. Educ. 10, 2, Article 8 (2010), 8:1-8:22 pages. https://doi.org/10.1145/1789934.1789938
  67. Chris Bennett. 2009. Student-authored wiki textbook in CS1. J. Comput. Sci. Coll. 24, 6 (2009), 50-56. http://dl.acm.org/citation.cfm?id=1529995.1530006
  68. Marc Berges and Peter Hubwieser. 2013. Concept specification maps: displaying content structures. In Proceedings of the 18th ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '13). ACM, New York, NY, USA, 291-296. https://doi.org/10.1145/2462476.2462503
  69. Marc Berges, Michael Striewe, Philipp Shah, Michael Goedicke, and Peter Hub- wieser. 2016. Towards deriving programming competencies from student er- rors. In International Conference on Learning and Teaching in Computing and Engineering (LaTiCE '16). IEEE, 19-23. https://doi.org/10.1109/LaTiCE.2016.6
  70. Anders Berglund and Raymond Lister. 2010. Introductory Programming and the Didactic Triangle. In Proceedings of the Twelfth Australasian Conference on Computing Education -Volume 103 (ACE '10). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 35-44.
  71. Matthew Berland, Taylor Martin, Tom Benton, Carmen Petrick Smith, and Don Davis. 2013. Using learning analytics to understand the learning pathways of novice programmers. Journal of the Learning Sciences 22, 4 (2013), 564-599. https://doi.org/10.1080/10508406.2013.836655
  72. Matthew Berland, Carmen Petrick Smith, and Don Davis. 2013. Visualizing live collaboration in the classroom with AMOEBA. In Computer-Supported Collaborative Learning Conference, CSCL, Vol. 2. International Society of the Learning Sciences, 2-5. https://doi.dx.org/10.22318/cscl2013.2
  73. Michael Berry and Michael Kölling. 2016. Novis: a notional machine imple- mentation for teaching introductory programming. In International Conference on Learning and Teaching in Computing and Engineering (LaTiCE '16). IEEE, 54-59. https://doi.org/10.1109/LaTiCE.2016.5
  74. Mária Bieliková. 2006. An adaptive web-based system for learning programming. International Journal of Continuing Engineering Education and Life-Long Learning 16, 1-2 (2006), 122-136. https://doi.org/10.1504/IJCEELL.2006.008922
  75. John Biggs. 1996. Enhancing teaching through constructive alignment. Higher education 32, 3 (1996), 347-364.
  76. John B. Biggs and Kevin F. Collis. 1982. Evaluating the quality of learning: the SOLO taxonomy (structure of the observed learning outcome). Academic Press.
  77. Don Blaheta. 2009. Democracy in the classroom: an exercise for the first days of CS1. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 36-39. https://doi.org/10.1145/1562877.1562895
  78. Ben Blake. 2010. BLAKE a language designed for programming I. Education and Information Technologies 15, 4 (2010), 277-291. https://doi.org/10.1007/ s10639-010-9139-3
  79. Douglas Blank, Jennifer S. Kay, James B. Marshall, Keith O'Hara, and Mark Russo. 2012. Calico: a multi-programming-language, multi-context framework designed for computer science education. In Proceedings of the 43rd ACM Technical Symposium on Computer Science Education (SIGCSE '12). ACM, New York, NY, USA, 63-68. https://doi.org/10.1145/2157136.2157158
  80. Imma Boada, Josep Soler, Ferran Prados, and Jordi Poch. 2004. A teach- ing/learning support tool for introductory programming courses. In Information Technology Based Proceedings of the Fifth International Conference on Higher Education and Training (ITHET '04). IEEE, 604-609. https://doi.org/10.1109/ ITHET.2004.1358243
  81. Michael G. Boland and Curtis Clifton. 2009. Introducing PyLighter: dynamic code highlighter. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 489-493. https://doi.org/10.1145/1508865.1509037
  82. Jürgen Börstler, Marie Nordström, Lena Kallin Westin, Jan-Erik Moström, and Johan Eliasson. 2008. Transitioning to OOP/Java -a never ending story. In Reflections on the Teaching of Programming: Methods and Implementations, Jens Bennedsen, Michael E. Caspersen, and Michael Kölling (Eds.). Springer, Berlin, Heidelberg, 80-97. https://doi.org/10.1007/978-3-540-77934-6_8
  83. Jürgen Börstler, Marie Nordström, and James H. Paterson. 2011. On the quality of examples in introductory Java textbooks. Trans. Comput. Educ. 11, 1, Article 3 (2011), 21 pages. https://doi.org/10.1145/1921607.1921610
  84. Nigel Bosch, Yuxuan Chen, and Sidney D'Mello. 2014. It's written on your face: detecting affective states from facial expressions while learning computer pro- gramming. In Intelligent Tutoring Systems. Springer International Publishing, 39-44. https://doi.org/10.1007/978-3-319-07221-0_5
  85. Matt Bower. 2007. Groupwork activities in synchronous online classroom spaces. In Proceedings of the 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '07). ACM, New York, NY, USA, 91-95. https://doi.org/10. 1145/1227310.1227345
  86. Kristy Elizabeth Boyer, August A. Dwight, R. Taylor Fondren, Mladen A. Vouk, and James C. Lester. 2008. A development environment for distributed syn- chronous collaborative programming. SIGCSE Bull. 40, 3 (2008), 158-162. https://doi.org/10.1145/1597849.1384315
  87. Kristy Elizabeth Boyer, Rachael S. Dwight, Carolyn S. Miller, C. Dianne Rauben- heimer, Matthias F. Stallmann, and Mladen A. Vouk. 2007. A case for smaller class size with integrated lab for introductory computer science. In Proceedings of the 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '07). ACM, New York, NY, USA, 341-345. https://doi.org/10.1145/ 1227310.1227430
  88. Steven Bradley. 2016. Managing plagiarism in programming assignments with blended assessment and randomisation. In Proceedings of the 16th Koli Calling International Conference on Computing Education Research (Koli Calling '16). ACM, New York, NY, USA, 21-30. https://doi.org/10.1145/2999541.2999560
  89. Grant Braught, L. Martin Eby, and Tim Wahls. 2008. The effects of pair- programming on individual programming skill. In Proceedings of the 39th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '08).
  90. ACM, New York, NY, USA, 200-204. https://doi.org/10.1145/1352135.1352207
  91. Grant Braught, John MacCormick, and Tim Wahls. 2010. The benefits of pairing by ability. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). ACM, New York, NY, USA, 249-253. https: //doi.org/10.1145/1734263.1734348
  92. Tom Briggs and C. Dudley Girard. 2007. Tools and techniques for test-driven learning in CS1. J. Comput. Sci. Coll. 22, 3 (2007), 37-43. http://dl.acm.org/ citation.cfm?id=1181849.1181854
  93. Neil C.C. Brown and Amjad Altadmri. 2014. Investigating novice programming mistakes: educator beliefs vs. student data. In Proceedings of the Tenth Annual Conference on International Computing Education Research (ICER '14). ACM, New York, NY, USA, 43-50. https://doi.org/10.1145/2632320.2632343
  94. Neil Christopher Charles Brown, Michael Kölling, Davin McCall, and Ian Ut- ting. 2014. Blackbox: a large scale repository of novice programmers' ac- tivity. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 223-228. https: //doi.org/10.1145/2538862.2538924
  95. Kim B. Bruce. 2005. Controversy on how to teach CS 1: a discussion on the SIGCSE-members mailing list. SIGCSE Bull. 37, 2 (2005), 111-117. https://doi. org/10.1145/1083431.1083477
  96. Kim B. Bruce, Andrea Danyluk, and Thomas Murtagh. 2005. Why structural recursion should be taught before arrays in CS 1. In Proceedings of the 36th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '05).
  97. ACM, New York, NY, USA, 246-250. https://doi.org/10.1145/1047344.1047430
  98. Kim B. Bruce, Andrea Danyluk, and Thomas Murtagh. 2010. Introducing con- currency in CS 1. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). ACM, New York, NY, USA, 224-228. https://doi.org/10.1145/1734263.1734341
  99. Michael P Bruce-Lockhart and Theodore S Norvell. 2007. Developing mental models of computer programming interactively via the web. In IEEE Frontiers in Education Conference (FIE '07). IEEE, S3H-3-S3H-8. https://doi.org/10.1109/ FIE.2007.4418051
  100. Peter Brusilovsky, Olena Shcherbinina, and Sergey Sosnovsky. 2004. Mini- languages for non-computer science majors: what are the benefits? Interactive Technology and Smart Education 1, 1 (2004), 21-28. https://doi.org/10.1108/ 17415650480000009
  101. Engin Bumbacher, Alfredo Sandes, Amit Deutsch, and Paulo Blikstein. 2013. Student coding styles as predictors of help-seeking behavior. In Lecture Notes in Computer Science. Springer, Berlin, Heidelberg, 856-859. https://doi.org/10. 1007/978-3-642-39112-5_130
  102. Carl Burch. 2009. Jigsaw, a programming environment for Java in CS1. J. Comput. Sci. Coll. 24, 5 (2009), 37-43. http://dl.acm.org/citation.cfm?id=1516595.1516604
  103. Ignacio Cabrera, Jorge Villalon, and Jorge Chavez. 2017. Blending communities and team-based learning in a programming course. IEEE Transactions on Education 60 (2017), 288-295. Issue 4. https://doi.org/10.1109/TE.2017.2698467
  104. Andrew Cain. 2013. Developing assessment criteria for portfolio assessed introductory programming. In Proceedings of IEEE International Conference on Teaching, Assessment and Learning for Engineering (TALE '13). IEEE, 55- 60. https://doi.org/10.1109/TALE.2013.6654399
  105. Andrew Cain. 2014. Factors influencing student learning in portfolio assessed introductory programming. In IEEE International Conference on Teaching, Assessment and Learning for Engineering (TALE '14). IEEE, 55-62. https: //doi.org/10.1109/TALE.2014.7062585
  106. Andrew Cain and Clinton J Woodward. 2012. Toward constructive align- ment with portfolio assessment for introductory programming. In Proceedings of IEEE International Conference on Teaching, Assessment, and Learning for Engineering (TALE '12). IEEE, H1B-11-H1B-17. https://doi.org/10.1109/TALE. 2012.6360322
  107. Andrew Cain, Clinton J Woodward, and Shannon Pace. 2013. Examining student progress in portfolio assessed introductory programming. In Proceedings of 2013 IEEE International Conference on Teaching, Assessment and Learning for Engineering (TALE). IEEE, 67-72. https://doi.org/10.1109/TALE.2013.6654401
  108. Ünal Çakıroğlu. 2014. Analyzing the effect of learning styles and study habits of distance learners on learning performances: a case of an introductory program- ming course. International Review of Research in Open and Distance Learning 15, 4 (2014), 161-185.
  109. Jennifer Campbell, Diane Horton, and Michelle Craig. 2016. Factors for success in online CS1. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 320-325. https://doi.org/10.1145/2899415.2899457
  110. Jennifer Campbell, Diane Horton, Michelle Craig, and Paul Gries. 2014. Evaluat- ing an inverted CS1. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 307-312. https://doi.org/10.1145/2538862.2538943
  111. Yingjun Cao, Leo Porter, and Daniel Zingaro. 2016. Examining the value of analo- gies in introductory computing. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER '16). ACM, New York, NY, USA, 231-239. https://doi.org/10.1145/2960310.2960313
  112. Antonella Carbonaro and Mirko Ravaioli. 2017. Peer assessment to promote deep learning and to reduce a gender gap in the traditional introductory programming course. Journal of E-Learning and Knowledge Society 13, 3 (2017), 121-129. https://doi.org/10.20368/1971-8829/1398
  113. Angela Carbone, John Hurst, Ian Mitchell, and Dick Gunstone. 2009. An ex- ploration of internal factors influencing student learning of programming. In Proceedings of the Eleventh Australasian Conference on Computing Education -Volume 95 (ACE '09). Australian Computer Society, Inc., Darlinghurst, Aus- tralia, Australia, 25-34. http://dl.acm.org/citation.cfm?id=1862712.1862721
  114. Rachel Cardell-Oliver. 2011. How can software metrics help novice program- mers?. In Proceedings of the Thirteenth Australasian Computing Education Conference -Volume 114 (ACE '11). Australian Computer Society, Inc., Dar- linghurst, Australia, Australia, 55-62. http://dl.acm.org/citation.cfm?id=2459936. 2459943
  115. Martin C. Carlisle. 2010. Using You Tube to enhance student class prepara- tion in an introductory Java course. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). ACM, New York, NY, USA, 470-474. https://doi.org/10.1145/1734263.1734419
  116. Jeffrey Carver and Lisa Hende. 2006. Viope as a tool for teaching introduc- tory programming: an empirical investigation. In 19th Conference on Software Engineering Education & Training (CSEET'06). IEEE, 9-16. https://doi.org/10. 1109/CSEET.2006.38
  117. Jeffrey C Carver, Lisa Henderson, Lulu He, Julia Hodges, and Donna Reese. 2007. Increased retention of early computer science and software engineering students using pair programming. In 20th Conference on Software Engineering Education & Training (CSEET'07). IEEE, 115-122. https://doi.org/10.1109/ CSEET.2007.29
  118. Michael E. Caspersen and Henrik Baerbak Christensen. 2008. CS1: getting started. In Reflections on the Teaching of Programming: Methods and Implementations, Jens Bennedsen, Michael E. Caspersen, and Michael Kölling (Eds.). Springer, Berlin, Heidelberg, 130-141. https://doi.org/10.1007/978-3-540-77934-6_11
  119. Francisco Enrique Vicente Castro and Kathi Fisler. 2016. On the interplay between bottom-up and datatype-driven program design. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 205-210. https://doi.org/10.1145/ 2839509.2844574
  120. Francisco Enrique Vicente Castro and Kathi Fisler. 2017. Designing a multi- faceted SOLO taxonomy to track program design skills through an entire course. In Proceedings of the 17th Koli Calling International Conference on Computing Education Research (Koli Calling '17). ACM, New York, NY, USA, 10-19. https: //doi.org/10.1145/3141880.3141891
  121. A. T. Chamillard. 2011. Using a student response system in CS1 and CS2. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 299-304. https://doi.org/ 10.1145/1953163.1953253
  122. Bruce Char. 2016. Automatic feedback systems for code: what can they tell the busy instructor? J. Comput. Sci. Coll. 31, 4 (2016), 87-93. http://dl.acm.org/ citation.cfm?id=2904127.2904143
  123. Spyropoulos Charalampos, Vassilios Dagdilelis, and Georgios Evangelidis. 2005. Teaching object-oriented thinking to novice programmers using the AgentSheets environment. In IADIS International Conference on Cognition and Exploratory Learning in Digital Age (CELDA '05). IADIS, 343-348.
  124. Therese Charles, David Bustard, and Michaela Black. 2011. Experiences of promoting student engagement through game-enhanced learning. In Serious Games and Edutainment Applications. Springer London, 425-445. https://doi. org/10.1007/978-1-4471-2161-9_21
  125. Tzu-Yi Chen, Gary Lewandowski, Robert McCartney, Kate Sanders, and Beth Simon. 2007. Commonsense computing: using student sorting abilities to im- prove instruction. In Proceedings of the 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '07). ACM, New York, NY, USA, 276-280. https://doi.org/10.1145/1227310.1227408
  126. Tzu-Yi Chen, Alvaro Monge, and Beth Simon. 2006. Relationship of early programming language to novice generated design. SIGCSE Bull. 38, 1 (2006), 495-499. https://doi.org/10.1145/1124706.1121496
  127. Donald Chinn, Judy Sheard, Angela Carbone, and Mikko-Jussi Laakso. 2010. Study habits of CS1 students: what do they do outside the classroom?. In Proceedings of the Twelfth Australasian Conference on Computing Education -Volume 103 (ACE '10). Australian Computer Society, Inc., Darlinghurst, Aus- tralia, Australia, 53-62. http://dl.acm.org/citation.cfm?id=1862219.1862229
  128. Chih-Yueh Chou and Peng-Fei Sun. 2013. An educational tool for visualizing students' program tracing processes. Computer Applications in Engineering Education 21, 3 (2013), 432-438. https://doi.org/10.1002/cae.20488
  129. Yu-kai Chou. 2015. Actionable gamification: beyond points, badges, and leaderboards. Octalysis Group.
  130. Rohan Roy Choudhury, Hezheng Yin, and Armando Fox. 2016. Scale-driven automatic hint generation for coding style. In Intelligent Tutoring Systems. Springer, Cham, 122-132. https://doi.org/10.1007/978-3-319-39583-8_12
  131. Vincent A. Cicirello. 2009. On the role and effectiveness of pop quizzes in CS1. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 286-290. https://doi.org/ 10.1145/1508865.1508971
  132. Daniel C Cliburn. 2006. The effectiveness of games as assignments in an in- troductory programming course. In IEEE Frontiers in Education Conference (FIE '06). IEEE, 6-10. https://doi.org/10.1109/FIE.2006.322314
  133. Daniel C Cliburn. 2008. Student opinions of Alice in CS1. In IEEE Frontiers in Education Conference (FIE '08). IEEE, T3B-1-T3B-6. https://doi.org/10.1109/ FIE.2008.4720254
  134. Daniel C Cliburn, Susan M Miller, and Emma Bowring. 2010. Student pref- erences between open-ended and structured game assignments in CS1. In IEEE Frontiers in Education Conference (FIE '10). IEEE, F2H-1-F2H-5. https: //doi.org/10.1109/FIE.2010.5673668
  135. Stephen Cooper, Wanda Dann, and Randy Pausch. 2003. Teaching objects-first in introductory computer science. In Proceedings of the 34th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '03). ACM, New York, NY, USA, 191-195. https://doi.org/10.1145/611892.611966
  136. Malcolm Corney, Donna Teague, and Richard N. Thomas. 2010. Engaging stu- dents in programming. In Proceedings of the Twelfth Australasian Conference on Computing Education -Volume 103 (ACE '10). Australian Computer Soci- ety, Inc., Darlinghurst, Australia, Australia, 63-72. http://dl.acm.org/citation. cfm?id=1862219.1862230
  137. Evandro B. Costa, Baldoino Fonseca, Marcelo Almeida Santana, Fabrísia Ferreira de Araújo, and Joilson Rego. 2017. Evaluating the effectiveness of educational data mining techniques for early prediction of students' academic failure in introductory programming courses. Computers in Human Behavior 73 (2017), 247-256. https://doi.org/10.1016/j.chb.2017.01.047
  138. Natalie J Coull and Ishbel MM Duncan. 2011. Emergent requirements for supporting introductory programming. Innovations in Teaching and Learning in Information and Computer Sciences 10, 1 (2011), 78-85. https://doi.org/10. 11120/ital.2011.10010078
  139. Michelle Craig and Andrew Petersen. 2016. Student difficulties with pointer concepts in C. In Proceedings of the Australasian Computer Science Week Multiconference (ACSW '16). ACM, New York, NY, USA, Article 8, 8:1- 8:10 pages. https://doi.org/10.1145/2843043.2843348
  140. Michelle Craig, Jacqueline Smith, and Andrew Petersen. 2017. Familiar con- texts and the difficulty of programming problems. In Proceedings of the 17th Koli Calling International Conference on Computing Education Research (Koli Calling '17). ACM, New York, NY, USA, 123-127. https://doi.org/10.1145/ 3141880.3141898
  141. Stewart Crawford and Elizabeth Boese. 2006. ActionScript: a gentle introduction to programming. J. Comput. Sci. Coll. 21, 3 (2006), 156-168. http://dl.acm.org/ citation.cfm?id=1089182.1089203
  142. James Cross, Dean Hendrix, Larry Barowski, and David Umphress. 2014. Dy- namic program visualizations: an experience report. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 609-614. https://doi.org/10.1145/2538862.2538958
  143. Gilbert Cruz, Jacob Jones, Meagan Morrow, Andres Gonzalez, and Bruce Gooch. 2017. An system for coaching novice programmers. In Learning and Collaboration Technologies. Technology in Education. Springer International Publishing, 12-21. https://doi.org/10.1007/978-3-319-58515-4_2
  144. Kathryn Cunningham, Sarah Blanchard, Barbara Ericson, and Mark Guzdial. 2017. Using tracing and sketching to solve programming problems: replicating and extending an analysis of what students draw. In Proceedings of the 2017 ACM Conference on International Computing Education Research (ICER '17). ACM, New York, NY, USA, 164-172. https://doi.org/10.1145/3105726.3106190
  145. Quintin Cutts, Emily Cutts, Stephen Draper, Patrick O'Donnell, and Peter Saf- frey. 2010. Manipulating mindset to positively influence introductory program- ming performance. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). ACM, New York, NY, USA, 431-435. https://doi.org/10.1145/1734263.1734409
  146. Quintin I. Cutts and Gregor E. Kennedy. 2005. Connecting learning environ- ments using electronic voting systems. In Proceedings of the 7th Australasian Conference on Computing Education -Volume 42 (ACE '05). Australian Com- puter Society, Inc., Darlinghurst, Australia, Australia, 181-186. http://dl.acm. org/citation.cfm?id=1082424.1082447
  147. Marin Aglić Čuvić, Josip Maras, and Saša Mladenović. 2017. Extending the object-oriented notional machine notation with inheritance, polymor- phism, and GUI events. In 40th International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO '17). IEEE, 794-799. https://doi.org/10.23919/MIPRO.2017.7973530
  148. Charlie Daly and Jane Horgan. 2005. Patterns of plagiarism. In Proceedings of the 36th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '05). ACM, New York, NY, USA, 383-387. https://doi.org/10.1145/ 1047344.1047473
  149. Sayamindu Dasgupta and Benjamin Mako Hill. 2017. Learning to code in local- ized programming languages. In Proceedings of the Fourth ACM Conference on Learning @ Scale (L@S '17). ACM, New York, NY, USA, 33-39. https: //doi.org/10.1145/3051457.3051464
  150. Mark Davies and Joseph L. Fleiss. 1982. Measuring agreement for multinomial data. Biometrics 38, 4 (1982), 1047-1051. http://www.jstor.org/stable/2529886
  151. Suzanne L. Dazo, Nicholas R. Stepanek, Robert Fulkerson, and Brian Dorn. 2016. An empirical analysis of video viewing behaviors in flipped CS1 courses. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 106-111. https://doi.org/10.1145/2899415.2899468
  152. Michael de Raadt. 2012. Student created cheat-sheets in examinations: impact on student outcomes. In Proceedings of the Fourteenth Australasian Computing Education Conference -Volume 123 (ACE '12). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 71-76. http://dl.acm.org/citation.cfm? id=2483716.2483725
  153. Michael de Raadt, David Lai, and Richard Watson. 2007. An evaluation of electronic individual peer assessment in an introductory programming course. In Proceedings of the Seventh Baltic Sea Conference on Computing Education Research -Volume 88 (Koli Calling '07). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 53-64. http://dl.acm.org/citation.cfm?id= 2449323.2449330
  154. Michael de Raadt, Richard Watson, and Mark Toleman. 2003. Language tug- of-war: industry demand and academic choice. In Proceedings of the Fifth Australasian Conference on Computing Education -Volume 20 (ACE '03). Aus- tralian Computer Society, Inc., Darlinghurst, Australia, Australia, 137-142. http://dl.acm.org/citation.cfm?id=858403.858420
  155. Michael de Raadt, Richard Watson, and Mark Toleman. 2004. Introductory programming: what's happening today and will there be any students to teach tomorrow?. In Proceedings of the Sixth Australasian Conference on Computing Education -Volume 30 (ACE '04). Australian Computer Society, Inc., Dar- linghurst, Australia, Australia, 277-282. http://dl.acm.org/citation.cfm?id= 979968.980005
  156. Michael de Raadt, Richard Watson, and Mark Toleman. 2009. Teaching and assessing programming strategies explicitly. In Proceedings of the Eleventh Australasian Conference on Computing Education -Volume 95 (ACE '09). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 45-54. http://dl.acm.org/citation.cfm?id=1862712.1862723
  157. Adrienne Decker and Elizabeth Lane Lawley. 2013. Life's a game and the game of life: how making a game out of it can change student behavior. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 233-238. https://doi.org/ 10.1145/2445196.2445269
  158. Adrienne Decker, Phil Ventura, and Christopher Egert. 2006. Through the looking glass: reflections on using undergraduate teaching assistants in CS1. In Proceedings of the 37th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '06). ACM, New York, NY, USA, 46-50. https://doi.org/10. 1145/1121341.1121358
  159. Paul Denny, Diana Cukierman, and Jonathan Bhaskar. 2015. Measuring the effect of inventing practice exercises on learning in an introductory program- ming course. In Proceedings of the 15th Koli Calling Conference on Computing Education Research (Koli Calling '15). ACM, New York, NY, USA, 13-22. https: //doi.org/10.1145/2828959.2828967
  160. Paul Denny, Andrew Luxton-Reilly, and Dave Carpenter. 2014. Enhancing syntax error messages appears ineffectual. In Proceedings of the 2014 Conference on Innovation & Technology in Computer Science Education (ITiCSE '14). ACM, New York, NY, USA, 273-278. https://doi.org/10.1145/2591708.2591748
  161. Paul Denny, Andrew Luxton-Reilly, John Hamer, Dana B. Dahlstrom, and He- len C. Purchase. 2010. Self-predicted and actual performance in an introductory programming course. In Proceedings of the Fifteenth Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '10). ACM, New York, NY, USA, 118-122. https://doi.org/10.1145/1822090.1822124
  162. Paul Denny, Andrew Luxton-Reilly, and Beth Simon. 2008. Evaluating a new exam question: Parsons problems. In Proceedings of the Fourth International Workshop on Computing Education Research (ICER '08). ACM, New York, NY, USA, 113-124. https://doi.org/10.1145/1404520.1404532
  163. Paul Denny, Andrew Luxton-Reilly, Ewan Tempero, and Jacob Hendrickx. 2011. Codewrite: supporting student-driven practice of Java. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 471-476. https://doi.org/10.1145/1953163.1953299
  164. Sebastian Deterding, Dan Dixon, Rilla Khaled, and Lennart Nacke. 2011. From game design elements to gamefulness: defining "gamification". In Proceedings of the 15th International Academic MindTrek Conference: Envisioning Future Media Environments (MindTrek '11). ACM, New York, NY, USA, 9-15. https: //doi.org/10.1145/2181037.2181040
  165. Adrian Devey and Angela Carbone. 2011. Helping first year novice program- ming students pass. In Proceedings of the Thirteenth Australasian Computing Education Conference -Volume 114 (ACE '11). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 135-144. http://dl.acm.org/citation.cfm? id=2459936.2459953
  166. Nicholas Diana, Michael Eagle, John Stamper, Shuchi Grover, Marie Bienkowski, and Satabdi Basu. 2017. An instructor dashboard for real-time analytics in inter- active programming assignments. In Proceedings of the Seventh International Learning Analytics & Knowledge Conference (LAK '17). ACM, New York, NY, USA, 272-279. https://doi.org/10.1145/3027385.3027441
  167. Paul E. Dickson. 2011. Motivating students taking CS1 by using image ma- nipulation in C and C+. J. Comput. Sci. Coll. 26, 6 (2011), 136-141. http: //dl.acm.org/citation.cfm?id=1968521.1968551
  168. Edward Dillon, Monica Anderson, and Marcus Brown. 2012. Comparing feature assistance between programming environments and their "effect" on novice programmers. J. Comput. Sci. Coll. 27, 5 (2012), 69-77. http://dl.acm.org/citation. cfm?id=2168874.2168894
  169. Edward Dillon, Monica Anderson, and Marcus Brown. 2012. Comparing mental models of novice programmers when using visual and command line envi- ronments. In Proceedings of the 50th Annual Southeast Regional Conference (ACM-SE '12). ACM, New York, NY, USA, 142-147. https://doi.org/10.1145/ 2184512.2184546
  170. Daghan Dinç and Suzan Üsküdarli. 2009. A web environment to support teach- ing introductory programming. In 2009 Fourth International Conference on Internet and Web Applications and Services. IEEE, 578-582. https://doi.org/10. 1109/ICIW.2009.93
  171. Zachary Dodds, Ran Libeskind-Hadas, and Eliot Bush. 2010. When CS 1 is Biology 1: crossdisciplinary collaboration as CS context. In Proceedings of the Fifteenth Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '10). ACM, New York, NY, USA, 219-223. https: //doi.org/10.1145/1822090.1822152
  172. Liam Doherty, J Shakya, M Jordanov, P Lougheed, D Brokenshire, S Rao, and VS Kumar. 2005. Recognizing opportunities for mixed-initiative inter- actions in novice programming. In AAAI Fall Symposium on Mixed-Initiative Problem-Solving Assistants. AAAI, 51-56.
  173. Brian Dorn and Allison Elliott Tew. 2015. Empirical validation and application of the computing attitudes survey. Computer Science Education 25, 1 (2015), 1-36. https://doi.org/10.1080/08993408.2015.1014142
  174. Brian Dorn and Dean Sanders. 2003. Using Jeroo to introduce object-oriented programming. In IEEE Frontiers in Education Conference (FIE '03), Vol. 1. IEEE, T4C-22-7 Vol.1. https://doi.org/10.1109/FIE.2003.1263372
  175. Ricardo Vargas Dorneles, Delcino Picinin Jr, and André Gustavo Adami. 2010. ALGOWEB: a web-based environment for learning introductory programming. In 10th IEEE International Conference on Advanced Learning Technologies (ICALT '10). IEEE, 83-85. https://doi.org/10.1109/ICALT.2010.30
  176. Mohsen Dorodchi, Nasrin Dehbozorgi, and Tonya K Frevert. 2017. "I wish I could rank my exam's challenge level!": An algorithm of Bloom's taxonomy in teaching CS1. In IEEE Frontiers in Education Conference (FIE '17). IEEE, 1-5. https://doi.org/10.1109/FIE.2017.8190523
  177. Daryl D'Souza, Margaret Hamilton, James Harland, Peter Muir, Charles The- vathayan, and Cecily Walker. 2008. Transforming learning of programming: a mentoring project. In Proceedings of the Tenth Conference on Australasian Computing Education -Volume 78 (ACE '08). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 75-84. http://dl.acm.org/citation.cfm? id=1379249.1379256
  178. Amalia Duch Brown, Joaquim Gabarró Vallès, Jordi Petit Silvestre, Maria Josep Blesa Aguilera, and María José Serna Iglesias. 2015. A cost-benefit analysis of continuous assessment. In Proceedings of the 7th International Conference on Computer Supported Education (CSEDU '15). SciTePress, 57-66.
  179. Mark S. Durrheim, Abejide Ade-Ibijola, and Sigrid Ewert. 2016. Code pathfinder: a stepwise programming e-tutor using plan mirroring. In Communications in Computer and Information Science. Springer International Publishing, 69-82. https://doi.org/10.1007/978-3-319-47680-3_7
  180. Thomas Dy and Ma. Mercedes Rodrigo. 2010. A detector for non-literal Java errors. In Proceedings of the 10th Koli Calling International Conference on Computing Education Research (Koli Calling '10). ACM, New York, NY, USA, 118-122. https://doi.org/10.1145/1930464.1930485
  181. Michael Eagle and Tiffany Barnes. 2009. Experimental evaluation of an educa- tional game for improved learning in introductory computing. SIGCSE Bull. 41, 1 (2009), 321-325. https://doi.org/10.1145/1539024.1508980
  182. Alice H Eagly and Shelly Chaiken. 1998. Attitude structure and function. In The Handbook of Social Psychology. McGraw-Hill.
  183. Anna Eckerdal, Mikko-Jussi Laakso, Mike Lopez, and Amitrajit Sarkar. 2011. Re- lationship between text and action conceptions of programming: a phenomeno- graphic and quantitative perspective. In Proceedings of the 16th Annual Joint Conference on Innovation and Technology in Computer Science Education (ITiCSE '11). ACM, New York, NY, USA, 33-37. https://doi.org/10.1145/1999747. 1999760
  184. Alex Edgcomb and Frank Vahid. 2014. Effectiveness of online textbooks vs. inter- active web-native content. In Proceedings of the 2014 ASEE Annual Conference. ASEE.
  185. Alex Edgcomb, Frank Vahid, Roman Lysecky, and Susan Lysecky. 2017. Getting students to earnestly do reading, studying, and homework in an introduc- tory programming class. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 171-176. https://doi.org/10.1145/3017680.3017732
  186. Alex Daniel Edgcomb, Frank Vahid, Roman Lysecky, and Susan Lysecky. 2017. An analysis of incorporating small coding exercises as homework in introductory programming courses. In Proceedings of the 2017 ASEE Annual Conference. ASEE.
  187. Stephen H. Edwards. 2004. Using software testing to move students from trial- and-error to reflection-in-action. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 26-30. https://doi.org/10.1145/971300.971312
  188. Stephen H. Edwards and Krishnan Panamalai Murali. 2017. CodeWorkout: short programming exercises with built-in data collection. In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 188-193. https://doi.org/10. 1145/3059009.3059055
  189. Stephen H. Edwards and Manuel A. Pérez-Quiñones. 2007. Experiences using test-driven development with an automated grader. J. Comput. Sci. Coll. 22, 3 (2007), 44-50. http://dl.acm.org/citation.cfm?id=1181849.1181855
  190. Stephen H. Edwards, Daniel S. Tilden, and Anthony Allevato. 2014. Pythy: improving the introductory Python programming experience. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 641-646. https://doi.org/10.1145/ 2538862.2538977
  191. Johan Eliasson, Lena Kallin Westin, and Marie Nordström. 2006. Investigating students' confidence in programming and problem solving. In IEEE Frontiers in Education Conference (FIE '06). IEEE, 22-27. https://doi.org/10.1109/FIE.2006. 322490
  192. Allison Elliott Tew and Brian Dorn. 2013. The case for validated tools in computer science education research. Computer 46, 9 (2013), 60-66.
  193. Joelle Elmaleh and Venky Shankararaman. 2017. Improving student learning in an introductory programming course using flipped classroom and competency framework. In IEEE Global Engineering Education Conference (EDUCON '17). IEEE, 49-55. https://doi.org/10.1109/EDUCON.2017.7942823
  194. Ashraf Elnagar and Mahir Ali. 2012. A modified team-based learning methodology for effective delivery of an introductory programming course. In Proceedings of the 13th Annual Conference on Information Technology Education (SIGITE '12). ACM, New York, NY, USA, 177-182. https://doi.org/10. 1145/2380552.2380604
  195. Richard J. Enbody, William F. Punch, and Mark McCullen. 2009. Python CS1 as preparation for C++ CS2. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 116- 120. https://doi.org/10.1145/1508865.1508907
  196. Kiran L. N. Eranki and Kannan M. Moudgalya. 2012. A collaborative ap- proach to scaffold programming efficiency using spoken tutorials and its evalua- tion. In 8th International Conference on Collaborative Computing: Networking, Applications and Worksharing (CollaborateCom '12). IEEE, 556-559. https: //ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=6450951
  197. Barbara J. Ericson, Kantwon Rogers, Miranda Parker, Briana Morrison, and Mark Guzdial. 2016. Identifying design principles for CS teacher ebooks through design-based research. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER '16). ACM, New York, NY, USA, 191-200. https://doi.org/10.1145/2960310.2960335
  198. Anthony Estey, Hieke Keuning, and Yvonne Coady. 2017. Automatically clas- sifying students in need of support by detecting changes in programming behaviour. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 189-194. https://doi.org/10.1145/3017680.3017790
  199. Jim Etheredge. 2004. CMeRun: program logic debugging courseware for CS1/CS2 students. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 22- 25. https://doi.org/10.1145/971300.971311
  200. Thomas R Etherington. 2016. Teaching introductory GIS programming to geographers using an open source Python approach. Journal of Geography in Higher Education 40, 1 (2016), 117-130. https://doi.org/10.1080/03098265.2015. 1086981
  201. Geela Venise Firmalo Fabic, Antonija Mitrovic, and Kourosh Neshatian. 2017. Investigating the effectiveness of menu-based self-explanation prompts in a mobile Python tutor. In Artificial Intelligence in Education, Elisabeth André, Ryan Baker, Xiangen Hu, Ma. Mercedes T. Rodrigo, and Benedict du Boulay (Eds.). Springer International Publishing, Cham, 498-501. https://doi.org/10. 1007/978-3-319-61425-0_49
  202. Lisa Facey-Shaw and Paul Golding. 2005. Effects of peer tutoring and attitude on academic performance of first year introductory programming students. In IEEE Frontiers in Education Conference (FIE '05). IEEE, S1E. https://doi.org/10. 1109/FIE.2005.1612175
  203. Katrina Falkner and David S Munro. 2009. Easing the transition: a collaborative learning approach. In Proceedings of the Eleventh Australasian Conference on Computing Education -Volume 95 (ACE '09). Australian Computer Society, Inc., Darlinghurst, Australia, 65-74. http://dl.acm.org/citation.cfm?id=1862712. 1862725
  204. Waleed Farag, Sanwar Ali, and Debzani Deb. 2013. Does language choice influence the effectiveness of online introductory programming courses?. In Proceedings of the 14th Annual ACM SIGITE Conference on Information Technology Education (SIGITE '13). ACM, New York, NY, USA, 165-170. https: //doi.org/10.1145/2512276.2512293
  205. Rob Faux. 2006. Impact of preprogramming course curriculum on learning in the first programming course. IEEE Transactions on Education 49 (2006), 11-15. Issue 1. https://doi.org/10.1109/TE.2005.852593
  206. Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, and Shriram Krishna- murthi. 2018. How to Design Programs: An Introduction to Programming and Computing. MIT Press.
  207. James B Fenwick Jr, Cindy Norris, Frank E Barry, Josh Rountree, Cole J Spicer, and Scott D Cheek. 2009. Another look at the behaviors of novice programmers. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 296-300. https://doi.org/ 10.1145/1508865.1508973
  208. José Luis Fernández Alemán and Youssef Oufaska. 2010. SAMtool, a tool for de- ducing and implementing loop patterns. In Proceedings of the Fifteenth Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '10). ACM, New York, NY, USA, 68-72. https://doi.org/10.1145/1822090. 1822111
  209. Kasper Fisker, Davin McCall, Michael Kölling, and Bruce Quig. 2008. Group work support for the BlueJ IDE. In Proceedings of the 13th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '08). ACM, New York, NY, USA, 163-168. https://doi.org/10.1145/1384271.1384316
  210. Fred Fonseca and Larry Spence. 2014. The karate kid method of problem based learning. In Innovative Practices in Teaching Information Sciences and Technology. Springer International Publishing, Cham., 9-17. https://doi.org/10. 1007/978-3-319-03656-4_2
  211. Davide Fossati, Barbara Di Eugenio, Christopher Brown, and Stellan Ohlsson. 2008. Learning linked lists: experiments with the iList system. In Intelligent Tutoring Systems. Springer, Berlin, Heidelberg, 80-89. https://doi.org/10.1007/ 978-3-540-69132-7_13
  212. Patrice Frison. 2015. A teaching assistant for algorithm construction. In Proceedings of the 2015 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '15). ACM, New York, NY, USA, 9-14. https://doi.org/10.1145/2729094.2742588
  213. Daniel Frost. 2008. Ucigame, a Java library for games. In Proceedings of the 39th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '08).
  214. ACM, New York, NY, USA, 310-314. https://doi.org/10.1145/1352135.1352243
  215. Luka Fürst and Viljan Mahnič. 2012. A cooperative development system for an interactive introductory programming course. World Transactions on Engineering and Technology Education 10, 2 (2012), 122-127.
  216. Judith Gal-Ezer, Tamar Vilner, and Ela Zur. 2009. Has the paradigm shift in CS1 a harmful effect on data structures courses: a case study. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 126-130. https://doi.org/10.1145/1508865.1508909
  217. Jianxiong Gao, Bei Pang, and Steven S Lumetta. 2016. Automated feedback frame- work for introductory programming courses. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 53-58. https://doi.org/10.1145/2899415. 2899440
  218. Ryan Garlick and Ebru Celikel Cankaya. 2010. Using Alice in CS1: a quantitative experiment. In Proceedings of the Fifteenth Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '10). ACM, New York, NY, USA, 165-168. https://doi.org/10.1145/1822090.1822138
  219. Stuart Garner. 2007. A program design tool to help novices learn programming. In Australian Society for Computers in Learning in Tertiary Education Annual Conference (ASCILITE '07). Australasian Society for Computers in Learning in Tertiary Education, 321-324.
  220. David Ginat and Eti Menashe. 2015. SOLO taxonomy for assessing novices' algorithmic design. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 452-457. https://doi.org/10.1145/2676723.2677311
  221. David Ginat and Ronit Shmalo. 2013. Constructive use of errors in teaching CS1. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 353-358. https://doi.org/ 10.1145/2445196.2445300
  222. Mark Goadrich. 2014. Incorporating tangible computing devices into CS1. J. Comput. Sci. Coll. 29, 5 (2014), 23-31. http://dl.acm.org/citation.cfm?id=2600623. 2600627
  223. Paul Golding, Lisa Facey-Shaw, and Vanesa Tennant. 2006. Effects of peer tutor- ing, attitude and personality on academic performance of first year introductory programming students. In IEEE Frontiers in Education Conference (FIE '06). IEEE, 7-12. https://doi.org/10.1109/FIE.2006.322662
  224. Michael H Goldwasser and David Letscher. 2007. Introducing network program- ming into a CS1 course. In Proceedings of the 12th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '07). ACM, New York, NY, USA, 19-22. https://doi.org/10.1145/1268784.1268793
  225. Michael H Goldwasser and David Letscher. 2009. A graphics package for the first day and beyond. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 206-210. https://doi.org/10.1145/1508865.1508945
  226. Anabela Jesus Gomes, Alvaro Nuno Santos, and António José Mendes. 2012. A study on students' behaviours and attitudes towards learning to pro- gram. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 132-137. https://doi.org/10.1145/2325296.2325331
  227. Gracielo Gonzalez. 2004. Constructivism in an introduction to programming course. J. Comput. Sci. Coll. 19 (2004), 299-305. http://dl.acm.org/citation.cfm? id=1050231.1050277
  228. Graciela Gonzalez. 2006. A systematic approach to active and cooperative learn- ing in CS1 and its effects on CS2. In Proceedings of the 37th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '06). ACM, New York, NY, USA, 133-137. https://doi.org/10.1145/1121341.1121386
  229. Morten Goodwin and Tom Drange. 2016. Teaching programming to large student groups through test driven development comparing established meth- ods with teaching based on test driven development. In Proceedings of the 8th International Conference on Computer Supported Education (CSEDU '16), Vol. 1. SciTePress, 281-288.
  230. Ira Greenberg, Deepak Kumar, and Dianna Xu. 2012. Creative coding and visual portfolios for CS1. In Proceedings of the 43rd ACM Technical Symposium on Computer Science Education (SIGCSE '12). ACM, New York, NY, USA, 247-252. https://doi.org/10.1145/2157136.2157214
  231. Paul Gries, Volodymyr Mnih, Jonathan Taylor, Greg Wilson, and Lee Zamparo. 2005. Memview: a pedagogically-motivated visual debugger. In IEEE Frontiers in Education Conference (FIE '05). IEEE, S1J-11. https://doi.org/10.1109/FIE. 2005.1612204
  232. Paul Gross and Kris Powers. 2005. Evaluating assessments of novice program- ming environments. In Proceedings of the First International Workshop on Computing Education Research (ICER '05). ACM, New York, NY, USA, 99-110. https://doi.org/10.1145/1089786.1089796
  233. Sebastian Gross and Niels Pinkwart. 2015. Towards an integrative learning environment for Java programming. In IEEE 15th International Conference on Advanced Learning Technologies (ICALT '15). IEEE, 24-28. https://doi.org/10. 1109/ICALT.2015.75
  234. Dee Gudmundsen, Lisa Olivieri, and Namita Sarawagi. 2011. Using Visual Logic ©: three different approaches in different courses -General Education, CS0, and CS1. J. Comput. Sci. Coll. 26, 6 (2011), 23-29. http://dl.acm.org/citation. cfm?id=1968521.1968529
  235. Minzhe Guo, Taolun Chai, and Kai Qian. 2010. Design of online runtime and testing environment for instant Java programming assessment. In 2010 Seventh International Conference on Information Technology: New Generations. IEEE, 1102-1106. https://doi.org/10.1109/ITNG.2010.227
  236. Mark Guzdial. 2003. A media computation course for non-majors. In Proceedings of the 8th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '03). ACM, New York, NY, USA, 104-108. https: //doi.org/10.1145/961511.961542
  237. Simo Haatainen, Antti-Jussi Lakanen, Ville Isomöttönen, and Vesa Lappalainen. 2013. A practice for providing additional support in CS1. In Learning and Teaching in Computing and Engineering (LaTiCE '13). IEEE, 178-183. https: //doi.org/10.1109/LaTiCE.2013.39
  238. Patricia Haden, Dale Parsons, Krissi Wood, and Joy Gasson. 2017. Student affect in CS1: insights from an easy data collection tool. In Proceedings of the 17th Koli Calling International Conference on Computing Education Research (Koli Calling '17). ACM, New York, NY, USA, 40-49. https://doi.org/10.1145/ 3141880.3141881
  239. Pari Delir Haghighi and Judy Sheard. 2005. Summative computer programming assessment using both paper and computer. In Towards Sustainable and Scalable Educational Innovations Informed by the Learning Sciences (ICCE '05). IOS Press, 67-75.
  240. John Hamer, Quintin Cutts, Jana Jackova, Andrew Luxton-Reilly, Robert McCart- ney, Helen Purchase, Charles Riedesel, Mara Saeli, Kate Sanders, and Judithe Sheard. 2008. Contributing student pedagogy. SIGCSE Bull. 40, 4 (2008), 194-212. https://doi.org/10.1145/1473195.1473242
  241. John Hamer, Helen C Purchase, Paul Denny, and Andrew Luxton-Reilly. [n. d.]. Quality of Peer Assessment in CS1. 27-36. https://doi.org/10.1145/1584322. 1584327
  242. Nadeem Abdul Hamid. 2012. Automated web-based user interfaces for novice programmers. In Proceedings of the 50th Annual Southeast Regional Conference (ACM-SE '12). ACM, New York, NY, USA, 42-47. https://doi.org/ 10.1145/2184512.2184523
  243. Nadeem Abdul Hamid. 2016. A generic framework for engaging online data sources in introductory programming courses. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 136-141. https://doi.org/10.1145/ 2899415.2899437
  244. Brian Hanks. 2005. Student performance in CS1 with distributed pair program- ming. In Proceedings of the 10th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '05). ACM, New York, NY, USA, 316-320. https://doi.org/10.1145/1067445.1067532
  245. Brian Hanks. 2006. Student attitudes toward pair programming. In Proceedings of the 11th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITICSE '06). ACM, New York, NY, USA, 113-117. https://doi.org/10.1145/1140124.1140156
  246. Brian Hanks. 2008. Problems encountered by novice pair programmers. J. Educ. Resour. Comput. 7, 4, Article 2 (2008), 2:1-2:13 pages. https://doi.org/10.1145/ 1316450.1316452
  247. Brian Hanks, Charlie McDowell, David Draper, and Milovan Krnjajic. 2004. Program quality with pair programming in CS1. In Proceedings of the 9th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '04). ACM, New York, NY, USA, 176-180. https: //doi.org/10.1145/1007996.1008043
  248. Brian Hanks, Laurie Murphy, Beth Simon, Renée McCauley, and Carol Zander. 2009. CS1 students speak: advice for students by students. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 19-23. https://doi.org/10.1145/1508865.1508875
  249. Michael R Hansen and Jens Thyge Kristensen. 2008. Experiences with functional programming in an introductory curriculum. In Reflections on the Teaching of Programming, Jens Bennedsen, Michael E. Caspersen, and Michael Kölling (Eds.).
  250. Springer, Berlin, Heidelberg, 30-46. https://doi.org/10.1007/978-3-540-77934-6_ 4
  251. Brian K Hare. 2013. Classroom interventions to reduce failure & withdrawal in CS1: a field report. J. Comput. Sci. Coll. 28, 5 (2013), 228-235. http://dl.acm. org/citation.cfm?id=2458569.2458618
  252. Douglas Harms. 2011. Personal robots in CS1: implementing the Myro API in Java. In Proceedings of the 12th International Conference on Computer Systems and Technologies (CompSysTech '11). ACM, New York, NY, USA, 552- 557. https://doi.org/10.1145/2023607.2023699
  253. Brian Harrington and Ayaan Chaudhry. 2017. TrAcademic: improving partic- ipation and engagement in CS1/CS2 with gamified practicals. In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 347-352. https: //doi.org/10.1145/3059009.3059052
  254. Nathan Harris and Charmain Cilliers. 2006. A program beacon recognition tool. In 2006 7th International Conference on Information Technology Based Higher Education and Training (ITHET '06). IEEE, 216-225. https://doi.org/10. 1109/ITHET.2006.339767
  255. Björn Hartmann, Daniel MacDougall, Joel Brandt, and Scott R Klemmer. 2010. What would other programmers do: suggesting solutions to error messages. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI '10). ACM, New York, NY, USA, 1019-1028. https://doi.org/10. 1145/1753326.1753478
  256. Andrew Head, Elena Glassman, Gustavo Soares, Ryo Suzuki, Lucas Figueredo, Loris D'Antoni, and Björn Hartmann. 2017. Writing reusable code feedback at scale with mixed-initiative program synthesis. In Proceedings of the Fourth ACM Conference on Learning @ Scale (L@S '17). ACM, New York, NY, USA, 89-98. https://doi.org/10.1145/3051457.3051467
  257. David Heaney and Charlie Daly. 2004. Mass production of individual feed- back. In Proceedings of the 9th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '04). ACM, New York, NY, USA, 117-121. https://doi.org/10.1145/1007996.1008029
  258. Bastiaan Heeren, Daan Leijen, and Arjan van IJzendoorn. 2003. Helium, for learn- ing Haskell. In Proceedings of the 2003 ACM SIGPLAN Workshop on Haskell (Haskell '03). ACM, New York, NY, USA, 62-71. https://doi.org/10.1145/871895. 871902
  259. Kenny Heinonen, Kasper Hirvikoski, Matti Luukkainen, and Arto Vihavainen. 2014. Using CodeBrowser to seek differences between novice programmers. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 229-234. https://doi.org/ 10.1145/2538862.2538981
  260. James Heliotis and Richard Zanibbi. 2011. Moving away from programming and towards computer science in the CS first year. J. Comput. Sci. Coll. 26, 3 (2011), 115-125. http://dl.acm.org/citation.cfm?id=1859159.1859183
  261. Arto Hellas, Juho Leinonen, and Petri Ihantola. 2017. Plagiarism in take-home exams: help-seeking, collaboration, and systematic cheating. In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 238-243. https://doi.org/10. 1145/3059009.3059065
  262. Joseph Henrich, Steven J Heine, and Ara Norenzayan. 2010. The weirdest people in the world? Behavioral and Brain Sciences 33, 2-3 (2010), 61-83.
  263. Pavel Herout and Premysl Brada. 2015. Duck Testing Enhancements for Automated Validation of Student Programmes. In Proceedings of the 7th International Conference on Computer Supported Education - Volume 1 (CSEDU '15). SciTePress, Portugal, 228-234. https://doi.org/10.5220/ 0005412902280234
  264. Matthew Hertz and Sarah Michele Ford. 2013. Investigating factors of student learning in introductory courses. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 195-200. https://doi.org/10.1145/2445196.2445254
  265. Michael Hilton and David S Janzen. 2012. On teaching arrays with test-driven learning in WebIDE. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 93-98. https://doi.org/10.1145/2325296.2325322
  266. Amanda M Holland-Minkley and Thomas Lombardi. 2016. Improving engage- ment in introductory courses with homework resubmission. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 534-539. https://doi.org/10.1145/ 2839509.2844576
  267. Mark A Holliday and David Luginbuhl. 2004. CS1 assessment using mem- ory diagrams. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 200-204. https://doi.org/10.1145/971300.971373
  268. Lars Josef Höök and Anna Eckerdal. 2015. On the bimodality in an intro- ductory programming course: an analysis of student performance factors. In International Conference on Learning and Teaching in Computing and Engineering (LaTiCE '15). IEEE, 79-86. https://doi.org/10.1109/LaTiCE.2015.25
  269. Dainal Hooshyar, Rodina Binti Ahmad, Mohd Hairul Nizam Md Nasir, and Wong Ching Mun. 2014. Flowchart-based approach to aid novice program- mers: a novel framework. In 2014 International Conference on Computer and Information Sciences (ICCOINS). IEEE, 1-5. https://doi.org/10.1109/ICCOINS. 2014.6868826
  270. Danial Hooshyar, Rodina Binti Ahmad, Mohd Hairul Nizam Md Nasir, Shaha- boddin Shamshirband, and Shi-Jinn Horng. 2015. Flowchart-based program- ming environments for improving comprehension and problem-solving skill of novice programmers: a survey. International Journal of Advanced Intelligence Paradigms 7, 1 (2015), 24-56.
  271. Danial Hooshyar, Rodina Binti Ahmad, Ram Gopal Raj, Mohd Hairul Nizam Md Nasir, Moslem Yousef, Shi-Jinn Horng, and Jože Rugelj. 2015. A flowchart-based multi-agent system for assisting novice programmers with problem solving activities. Malaysian Journal of Computer Science 28, 2 (2015), 132-151.
  272. Danial Hooshyar, Rodina Binti Ahmad, Moslem Yousefi, Moein Fathi, Shi-Jinn Horng, and Heuiseok Lim. 2018. SITS: a solution-based intelligent tutoring system for students' acquisition of problem-solving skills in computer pro- gramming. Innovations in Education and Teaching International 55, 3 (2018), 325-335. https://doi.org/10.1080/14703297.2016.1189346
  273. Danial Hooshyar, Rodina Binti Ahmad, Moslem Yousefi, FD Yusop, and S-J Horng. 2015. A flowchart-based intelligent tutoring system for improving problem-solving skills of novice programmers. Journal of Computer Assisted Learning 31, 4 (2015), 345-361. https://doi.org/10.1111/jcal.12099
  274. V Horner and P Gouws. 2016. E-tutoring support for undergraduate stu- dents learning computer programming at the university of South Africa. In Proceedings of the Computer Science Education Research Conference 2016 (CSERC '16). ACM, New York, NY, USA, 29-36. https://doi.org/10.1145/2998551. 2998557
  275. Diane Horton, Jennifer Campbell, and Michelle Craig. 2016. Online CS1: who enrols, why, and how do they do?. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 323-328. https://doi.org/10.1145/2839509.2844578
  276. David Hovemeyer and David Babcock. 2009. Using terminal window graphics in CS1. J. Comput. Sci. Coll. 24, 3 (2009), 151-158. http://dl.acm.org/citation. cfm?id=1409873.1409902
  277. David Hovemeyer, Arto Hellas, Andrew Petersen, and Jaime Spacco. 2016. Control-flow-only abstract syntax trees for analyzing students' program- ming progress. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER '16). ACM, New York, NY, USA, 63-72. https://doi.org/10.1145/2960310.2960326
  278. Wen Chin Hsu and Scott W Plunkett. 2016. Attendance and grades in learning programming classes. In Proceedings of the Australasian Computer Science Week Multiconference (ACSW '16). ACM, New York, NY, USA, Article 4, 4:1- 4:6 pages. https://doi.org/10.1145/2843043.2843061
  279. Minjie Hu, Michael Winikoff, and Stephen Cranefield. 2012. Teaching novice programming using goals and plans in a visual notation. In Proceedings of the Fourteenth Australasian Computing Education Conference -Volume 123 (ACE '12). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 43-52. http://dl.acm.org/citation.cfm?id=2483716.2483722
  280. Minjie Hu, Michael Winikoff, and Stephen Cranefield. 2013. A process for novice programming using goals and plans. In Proceedings of the Fifteenth Australasian Computing Education Conference -Volume 136 (ACE '13). Aus- tralian Computer Society, Inc., Darlinghurst, Australia, Australia, 3-12. http: //dl.acm.org/citation.cfm?id=2667199.2667200
  281. Yun-Jen Hu and Po-Yao Chao. 2015. A simulation-based learning environment for learning debugging. In Proceedings of the 23rd International Conference on Computers in Education (ICCE '15). 310-312.
  282. Chenn-Jung Huang, Chen Chun-Hua, Luo Yun-Cheng, Chen Hong-Xin, and Yi-Ta Chuang. 2008. Developing an intelligent diagnosis and assessment e- learning tool for introductory programming. Journal of Educational Technology & Society 11, 4 (2008), 139-157.
  283. JL Huff and HR Clements. 2017. The hidden person within the frustrated student: an interpretative phenomenological analysis of a student's experience in a programming course. In American Society for Engineering Education Annual Conference & Exposition. ASEE.
  284. Bowen Hui and Shannon Farvolden. 2017. How can learning analytics im- prove a course?. In Proceedings of the 22nd Western Canadian Conference on Computing Education (WCCCE '17). ACM, New York, NY, USA, Article 1, 6 pages. https://doi.org/10.1145/3085585.3085586
  285. Christopher Hundhausen, Anukrati Agrawal, Dana Fairbrother, and Michael Trevisan. 2009. Integrating pedagogical code reviews into a CS 1 course: an empirical study. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 291-295. https://doi.org/10.1145/1508865.1508972
  286. Christopher Hundhausen, Anukrati Agrawal, Dana Fairbrother, and Michael Trevisan. 2010. Does studio-based instruction work in CS 1?: an empirical com- parison with a traditional approach. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). ACM, New York, NY, USA, 500-504. https://doi.org/10.1145/1734263.1734432
  287. Christopher Hundhausen, Anukrati Agrawal, and Kyle Ryan. 2010. The design of an online environment to support pedagogical code reviews. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). ACM, New York, NY, USA, 182-186. https://doi.org/ 10.1145/1734263.1734324
  288. Christopher D Hundhausen, Pawan Agarwal, and Michael Trevisan. 2011. On- line vs. face-to-face pedagogical code reviews: an empirical comparison. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 117-122. https://doi.org/ 10.1145/1953163.1953201
  289. Christopher D Hundhausen and Jonathan Lee Brown. 2007. An experimental study of the impact of visual semantic feedback on novice programming. Journal of Visual Languages & Computing 18, 6 (2007), 537-559. https://doi.org/10.1016/ j.jvlc.2006.09.001
  290. Christopher D Hundhausen and Jonathan L Brown. 2007. What you see is what you code: a "live" algorithm development and visualization environment for novice learners. Journal of Visual Languages & Computing 18, 1 (2007), 22-47. https://doi.org/10.1016/j.jvlc.2006.03.002
  291. Christopher D Hundhausen and Jonathan L Brown. 2008. Designing, visualiz- ing, and discussing algorithms within a CS 1 studio experience: an empirical study. Computers & Education 50, 1 (2008), 301-326. https://doi.org/10.1016/j. compedu.2006.06.002
  292. Christopher D Hundhausen, Sarah A Douglas, and John T Stasko. 2002. A meta- study of algorithm visualization effectiveness. Journal of Visual Languages & Computing 13, 3 (2002), 259-290. https://doi.org/10.1006/jvlc.2002.0237
  293. Christopher D Hundhausen, Sean Farley, and Jonathan Lee Brown. 2006. Can direct manipulation lower the barriers to programming and promote positive transfer to textual programming? An experimental study. In IEEE Symposium on Visual Languages and Human-Centric Computing, 2006 (VL/HCC'06). IEEE, 157-164. https://doi.org/10.1109/VLHCC.2006.12
  294. Christopher D Hundhausen, N Hari Narayanan, and Martha E Crosby. 2008. Exploring studio-based instructional models for computing education. In Proceedings of the 39th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '08). ACM, New York, NY, USA, 392-396. https://doi.org/ 10.1145/1352135.1352271
  295. Jacqueline Hundley. 2008. A review of using design patterns in CS1. In Proceedings of the 46th Annual Southeast Regional Conference (ACM-SE 46). ACM, New York, NY, USA, 30-33. https://doi.org/10.1145/1593105.1593113
  296. Jacqueline Hundley and Winard Britt. 2009. Engaging students in soft- ware development course projects. In The Fifth Richard Tapia Celebration of Diversity in Computing Conference: Intellect, Initiatives, Insight, and Innovations (TAPIA '09). ACM, New York, NY, USA, 87-92. https://doi.org/ 10.1145/1565799.1565820
  297. Petri Ihantola, Tuukka Ahoniemi, Ville Karavirta, and Otto Seppälä. 2010. Review of Recent Systems for Automatic Assessment of Programming Assignments. In Proceedings of the 10th Koli Calling International Conference on Computing Education Research (Koli Calling '10). ACM, New York, NY, USA, 86-93. https: //doi.org/10.1145/1930464.1930480
  298. Petri Ihantola, Arto Vihavainen, Alireza Ahadi, Matthew Butler, Jürgen Börstler, Stephen H Edwards, Essi Isohanni, Ari Korhonen, Andrew Petersen, Kelly Rivers, Miguel Ángel Rubio, Judy Sheard, Bronius Skupas, Jaime Spacco, Claudia Szabo, and Daniel Toll. 2015. Educational data mining and learning analytics in programming: literature review and case studies. In Proceedings of the 2015 ITiCSE on Working Group Reports (ITICSE-WGR '15). ACM, New York, NY, USA, 41-63. https://doi.org/10.1145/2858796.2858798
  299. Ville Isomöttönen and Vesa Lappalainen. 2012. CSI with games and an emphasis on TDD and unit testing: piling a trend upon a trend. ACM Inroads 3, 3 (2012), 62-68. https://doi.org/10.1145/2339055.2339073
  300. Mirjana Ivanović, Zoran Budimac, Miloš Radovanović, and Miloš Savić. 2015. Does the choice of the first programming language influence students' grades?. In Proceedings of the 16th International Conference on Computer Systems and Technologies (CompSysTech '15). ACM, New York, NY, USA, 305-312. https: //doi.org/10.1145/2812428.2812448
  301. Janusz Jablonowski. 2004. Some remarks on teaching of programming. In Proceedings of the 5th International Conference on Computer Systems and Technologies (CompSysTech '04). ACM, New York, NY, USA, 1-6. https://doi. org/10.1145/1050330.1050419
  302. James Jackson, Michael Cobb, and Curtis Carver. 2005. Identifying top Java errors for novice programmers. In IEEE Frontiers in Education Conference (FIE '05). IEEE, T4C-T4C. https://doi.org/10.1109/FIE.2005.1611967
  303. Matthew C Jadud. 2006. Methods and tools for exploring novice compilation behaviour. In Proceedings of the Second International Workshop on Computing Education Research (ICER '06). ACM, New York, NY, USA, 73-84. https://doi. org/10.1145/1151588.1151600
  304. Matthew C Jadud and Poul Henriksen. 2009. Flexible, reusable tools for studying novice programmers. In Proceedings of the Fifth International Workshop on Computing Education Research Workshop (ICER '09). ACM, New York, NY, USA, 37-42. https://doi.org/10.1145/1584322.1584328
  305. Siti Robaya Jantan and Syed Ahmad Aljunid. 2012. An experimental evaluation of scaffolded educational games design for programming. In IEEE Conference on Open Systems (ICOS '12). IEEE, 1-6. https://doi.org/10.1109/ICOS.2012.6417631
  306. Ambikesh Jayal, Stasha Lauria, Allan Tucker, and Stephen Swift. 2011. Python for teaching introductory programming: a quantitative evaluation. ITALICS Innovations in Teaching and Learning in Information and Computer Sciences 10, 1 (2011), 86-90. https://doi.org/10.11120/ital.2011.10010086
  307. Mehdi Jazayeri. 2015. Combining mastery learning with project-based learning in a first programming course: an experience report. In Proceedings of the 37th International Conference on Software Engineering -Volume 2 (ICSE '15). IEEE Press, Piscataway, NJ, USA, 315-318. http://dl.acm.org/citation.cfm?id= 2819009.2819059
  308. Jam Jenkins, Evelyn Brannock, Thomas Cooper, Sonal Dekhane, Mark Hall, and Michael Nguyen. 2012. Perspectives on active learning and collaboration: javaw- ide in the classroom. In Proceedings of the 43rd ACM Technical Symposium on Computer Science Education (SIGCSE '12). ACM, New York, NY, USA, 185-190. https://doi.org/10.1145/2157136.2157194
  309. Åse Jevinger and Kristina Von Hausswolff. 2016. Large programming task vs questions-and-answers examination in Java introductory courses. In International Conference on Learning and Teaching in Computing and Engineering (LaTiCE '16). IEEE, 154-161. https://doi.org/10.1109/LaTiCE.2016. 25
  310. Wei Jin and Albert Corbett. 2011. Effectiveness of cognitive apprenticeship learning (CAL) and cognitive tutors (CT) for problem solving using fundamental programming concepts. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 305- 310. https://doi.org/10.1145/1953163.1953254
  311. Wei Jin, Albert Corbett, Will Lloyd, Lewis Baumstark, and Christine Rolka. 2014. Evaluation of guided-planning and assisted-coding with task relevant dynamic hinting. In International Conference on Intelligent Tutoring Systems. Springer International Publishing, Cham., 318-328. https://doi.org/10.1007/ 978-3-319-07221-0_40
  312. Chris Johnson. 2012. SpecCheck: automated generation of tests for interface con- formance. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 186-191. https://doi.org/10.1145/2325296.2325343
  313. Chris Johnson, Monica McGill, Durell Bouchard, Michael K Bradshaw, Víctor A Bucheli, Laurence D Merkle, Michael James Scott, Z Sweedyk, J Ángel Velázquez- Iturbide, Zhiping Xiao, and Ming Zhang. 2016. Game development for computer science education. In Proceedings of the 2016 ITiCSE Working Group Reports (ITiCSE '16). ACM, New York, NY, USA, 23-44. https://doi.org/10.1145/3024906. 3024908
  314. Mary Elizabeth "ME" Jones, Melanie Kisthardt, and Marie A Cooper. 2011. Interdisciplinary teaching: introductory programming via creative writing. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 523-528. https://doi.org/ 10.1145/1953163.1953313
  315. Francisco Jurado, Ana I Molina, Miguel A Redondo, Manuel Ortega, Adam Giemza, Lars Bollen, and Heinz Ulrich Hoppe. 2009. Learning to program with COALA, a distributed computer assisted environment. Journal of Universal Computer Science 15, 7 (2009), 1472-1485.
  316. Erkki Kaila, Teemu Rajala, Mikko-Jussi Laakso, and Tapio Salakoski. 2009. Ef- fects, experiences and feedback from studies of a program visualization tool. Informatics in Education 8, 1 (2009), 17-34.
  317. Geetha Kanaparan, Rowena Cullen, and David Mason. 2013. Self-efficacy and engagement as predictors of student programming performance. In PACIS 2013
  318. Pertti Kansanen. 1999. Teaching as teaching-studying-learning interaction. Scandinavian Journal of Educational Research 43, 1 (1999), 81-89.
  319. Oscar Karnalim. 2016. Detecting source code plagiarism on introductory pro- gramming course assignments using a bytecode approach. In International Conference on Information & Communication Technology and Systems (ICTS '16). IEEE, 63-68. https://doi.org/10.1109/ICTS.2016.7910274
  320. Petra Kastl, Oliver Krisch, and Ralf Romeike. 2017. 3D printing as medium for mo- tivation and creativity in computer science lessons. In International Conference on Informatics in Schools: Situation, Evolution, and Perspectives. Springer In- ternational Publishing, 27-36. https://doi.org/10.1007/978-3-319-71483-7_3
  321. Nadia Kasto, Jacqueline Whalley, Anne Philpott, and David Whalley. 2014. Solu- tion spaces. In Proceedings of the Sixteenth Australasian Computing Education Conference -Volume 148 (ACE '14). Australian Computer Society, Inc., Dar- linghurst, Australia, Australia, 133-137. http://dl.acm.org/citation.cfm?id= 2667490.2667506
  322. Aaron Keen and Kurt Mammen. 2015. Program decomposition and complexity in CS1. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 48-53. https://doi. org/10.1145/2676723.2677219
  323. Hansi Keijonen, Jaakko Kurhila, and Arto Vihavainen. 2013. Carry-on effect in extreme apprenticeship. In IEEE Frontiers in Education Conference (FIE '13). IEEE, 1150-1155. https://doi.org/10.1109/FIE.2013.6685011
  324. Caitlin Kelleher and Randy Pausch. 2005. Lowering the barriers to program- ming: a taxonomy of programming environments and languages for novice programmers. ACM Comput. Surv. 37, 2 (2005), 83-137. https://doi.org/10.1145/ 1089733.1089734
  325. Hieke Keuning, Johan Jeuring, and Bastiaan Heeren. 2016. Towards a system- atic review of automated feedback generation for programming exercises. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 41-46. https://doi.org/10.1145/2899415.2899422
  326. Nazish Zaman Khan and Andrew Luxton-Reilly. 2016. Is computing for social good the solution to closing the gender gap in computer science?. In Proceedings of the Australasian Computer Science Week Multiconference (ACSW '16). ACM, New York, NY, USA, Article 17, 17:1-17:5 pages. https: //doi.org/10.1145/2843043.2843069
  327. Hassan Khosravi and Kendra M.L. Cooper. 2017. Using learning analytics to investigate patterns of performance and engagement in large classes. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 309-314. https: //doi.org/10.1145/3017680.3017711
  328. Suin Kim, Jae Won Kim, Jungkook Park, and Alice Oh. 2016. Elice: an on- line CS education platform to understand how students learn programming. In Proceedings of the Third ACM Conference on Learning @ Scale (L@S '16). ACM, New York, NY, USA, 225-228. https://doi.org/10.1145/2876034.2893420
  329. Päivi Kinnunen and Lauri Malmi. 2006. Why students drop out CS1 course?. In Proceedings of the Second International Workshop on Computing Education Research (ICER '06). ACM, New York, NY, USA, 97-108. https://doi.org/10.1145/ 1151588.1151604
  330. Paivi Kinnunen and Beth Simon. 2010. Experiencing programming assignments in CS1: the emotional toll. In Proceedings of the Sixth International Workshop on Computing Education Research (ICER '10). ACM, New York, NY, USA, 77-86. https://doi.org/10.1145/1839594.1839609
  331. Päivi Kinnunen and Beth Simon. 2011. CS majors' self-efficacy perceptions in CS1: results in light of social cognitive theory. In Proceedings of the Seventh International Workshop on Computing Education Research (ICER '11). ACM, New York, NY, USA, 19-26. https://doi.org/10.1145/2016911.2016917
  332. Päivi Kinnunen and Beth Simon. 2012. My program is ok-am I? Computing freshmen's experiences of doing programming assignments. Computer Science Education 22, 1 (2012), 1-28. https://doi.org/10.1080/08993408.2012.655091
  333. Päivi Kinnunen and Beth Simon. 2012. Phenomenography and grounded theory as research methods in computing education research field. Computer Science Education 22, 2 (2012), 199-218. https://doi.org/10.1080/08993408.2012.692928
  334. Stephen Kirby, Benjamin Toland, and Catherine Deegan. 2010. Program visuali- sation tool for teaching programming in C. In Proceedings of the International Conference on Education, Training and Informatics (ICETI'10). 457-461.
  335. Michael S. Kirkpatrick and Chris Mayfield. 2017. Evaluating an alternative CS1 for students with prior programming experience. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 333-338. https://doi.org/10.1145/ 3017680.3017759
  336. Paul A Kirschner. 2017. Stop propagating the learning styles myth. Computers & Education 106 (2017), 166-171.
  337. Gabor Kiss and Zuzanna Arki. 2017. The influence of game-based program- ming education on the algorithmic thinking. Procedia-Social and Behavioral Sciences 237 (2017), 613-617. https://doi.org/10.1016/j.sbspro.2017.02.020
  338. Yoshihiro Kita, Tetsuro Katayama, and Shigeyuki Tomita. 2007. Implemen- tation and evaluation of an automatic visualization tool "PGT" for program- ming education. In 5th ACIS International Conference on Software Engineering Research, Management & Applications (SERA 2007). IEEE, 213-220. https: //doi.org/10.1109/SERA.2007.92
  339. Barbara Kitchenham. 2004. Procedures for performing systematic reviews. Keele, UK, Keele University 33, 2004 (2004), 1-26.
  340. Antti Knutas, Jouni Ikonen, Uolevi Nikula, and Jari Porras. 2014. Increasing collaborative communications in a programming course with gamification: a case study. In Proceedings of the 15th International Conference on Computer Systems and Technologies (CompSysTech '14). ACM, New York, NY, USA, 370- 377. https://doi.org/10.1145/2659532.2659620
  341. A. J. Ko. 2003. Preserving non-programmers' motivation with error- prevention and debugging support tools. In IEEE Symposium on Human Centric Computing Languages and Environments, 2003. Proceedings. 2003. IEEE, 271- 272. https://doi.org/10.1109/HCC.2003.1260245
  342. Andrew J. Ko. 2009. Attitudes and self-efficacy in young adults' computing autobiographies. In IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC '09). IEEE, 67-74. https://doi.org/10.1109/VLHCC.2009. 5295297
  343. Andrew J. Ko and Brad A. Myers. 2008. Debugging reinvented: asking and answering why and why not questions about program behavior. In Proceedings of the 30th International Conference on Software Engineering (ICSE '08). ACM, New York, NY, USA, 301-310. https://doi.org/10.1145/1368088.1368130
  344. Yousun Ko, Bernd Burgstaller, and Bernhard Scholz. 2013. Parallel from the beginning: the case for multicore programming in the computer science under- graduate curriculum. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 415-420. https://doi.org/10.1145/2445196.2445320
  345. Kimberle Koile and David Singer. 2006. Improving learning in CS1 via tablet-pc-based in-class assessment. In Proceedings of the Second International Workshop on Computing Education Research (ICER '06). ACM, New York, NY, USA, 119-126. https://doi.org/10.1145/1151588.1151607
  346. Michael Kölling. 2008. Using BlueJ to introduce programming. In Reflections on the Teaching of Programming, Jens Bennedsen, Michael E. Caspersen, and Michael Kölling (Eds.). Springer, Berlin, Heidelberg, 98-115. https://doi.org/10. 1007/978-3-540-77934-6_9
  347. Steven Kollmansberger. 2010. Helping students build a mental model of compu- tation. In Proceedings of the Fifteenth Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '10). ACM, New York, NY, USA, 128-131. https://doi.org/10.1145/1822090.1822127
  348. Mario Konecki, Sandra Lovrenčić, and Matija Kaniški. 2016. Using real projects as motivators in programming education. In 39th International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO '16). IEEE, 883-886. https://doi.org/10.1109/MIPRO. 2016.7522264
  349. Yana Kortsarts and Yulia Kempner. 2012. Enriching introductory programming courses with non-intuitive probability experiments component. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 128-131. https://doi.org/10.1145/2325296.2325330
  350. Aditi Kothiyal, Rwitajit Majumdar, Sahana Murthy, and Sridhar Iyer. 2013. Effect of think-pair-share in a large CS1 class: 83% sustained engagement. In Proceedings of the Ninth Annual International ACM Conference on International Computing Education Research (ICER '13). ACM, New York, NY, USA, 137-144. https://doi.org/10.1145/2493394.2493408
  351. Aditi Kothiyal, Sahana Murthy, and Sridhar Iyer. 2014. Think-pair-share in a large CS1 class: does learning really happen?. In Proceedings of the 2014 Conference on Innovation & Technology in Computer Science Education (ITiCSE '14). ACM, New York, NY, USA, 51-56. https://doi.org/10.1145/2591708. 2591739
  352. Theodora Koulouri, Stanislao Lauria, and Robert D. Macredie. 2014. Teaching introductory programming: a quantitative evaluation of different approaches. Trans. Comput. Educ. 14, 4, Article 26 (2014), 26:1-26:28 pages. https://doi.org/ 10.1145/2662412
  353. Svetlana Kouznetsova. 2007. Using bluej and blackjack to teach object-oriented design concepts in CS1. J. Comput. Sci. Coll. 22, 4 (2007), 49-55. http://dl.acm. org/citation.cfm?id=1229637.1229646
  354. Feng-Yang Kuo, Wen-Hsiung Wu, and Cathy S Lin. 2013. An investigation of self-regulatory mechanisms in learning to program Visual Basic. Journal of Educational Computing Research 49, 2 (2013), 225-247. https://doi.org/10.2190/ EC.49.2.f
  355. Jaakko Kurhila and Arto Vihavainen. 2011. Management, structures and tools to scale up personal advising in large programming courses. In Proceedings of the 2011 Conference on Information Technology Education (SIGITE '11). ACM, New York, NY, USA, 3-8. https://doi.org/10.1145/2047594.2047596
  356. Lisa L. Lacher and Mark C. Lewis. 2015. The effectiveness of video quizzes in a flipped class. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 224-228. https://doi.org/10.1145/2676723.2677302
  357. Essi Lahtinen and Tuukka Ahoniemi. 2007. Annotations for defining interactive instructions to interpreter based program visualization tools. Electronic Notes in Theoretical Computer Science 178 (2007), 121-128. https://doi.org/10.1016/j. entcs.2007.01.041
  358. Essi Lahtinen and Tuukka Ahoniemi. 2009. Kick-start activation to novice programming -a visualization-based approach. Electronic Notes in Theoretical Computer Science 224 (2009), 125-132. https://doi.org/10.1016/j.entcs.2008.12. 056
  359. Essi Lahtinen, Kirsti Ala-Mutka, and Hannu-Matti Järvinen. 2005. A study of the difficulties of novice programmers. In Proceedings of the 10th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '05). ACM, New York, NY, USA, 14-18. https://doi.org/10.1145/1067445. 1067453
  360. Chien-Hung Lai, Wei-Ching Lin, Bin-Shyan Jong, and Yen-Teh Hsia. 2013. Java assist learning system for assisted learning on facebook. In Learning and Teaching in Computing and Engineering (LaTiCE '13). IEEE, 77-82. https: //doi.org/10.1109/LaTiCE.2013.10
  361. Antti-Jussi Lakanen, Vesa Lappalainen, and Ville Isomöttönen. 2015. Re- visiting rainfall to explore exam questions and performance on CS1. In Proceedings of the 15th Koli Calling Conference on Computing Education Research (Koli Calling '15). ACM, New York, NY, USA, 40-49. https://doi.org/ 10.1145/2828959.2828970
  362. Maria S. W. Lam, Eric Y. K. Chan, Victor C. S. Lee, and Y. T. Yu. 2008. Design- ing an automatic debugging assistant for improving the learning of computer programming. In International Conference on Hybrid Learning and Education (ICHL '08). Springer, Berlin, Heidelberg, 359-370. https://doi.org/10.1007/ 978-3-540-85170-7_32
  363. H Chad Lane and Kurt VanLehn. 2004. A dialogue-based tutoring system for beginning programming. In Proceedings of the Seventeenth International Florida Artificial Intelligence Research Society Conference (FLAIRS '04), Vol. 2. AAAI, 449-454. http://www.aaai.org/Papers/FLAIRS/2004/Flairs04-078.pdf
  364. Vesa Lappalainen, Antti-Jussi Lakanen, and Harri Högmander. 2017. To- wards computer-based exams in CS1. In Proceedings of the 9th International Conference on Computer Supported Education (CSEDU '17), Vol. 2. SciTePress, 125-136.
  365. Patricia Lasserre and Carolyn Szostak. 2011. Effects of team-based learning on a CS1 course. In Proceedings of the 16th Annual Joint Conference on Innovation and Technology in Computer Science Education (ITiCSE '11). ACM, New York, NY, USA, 133-137. https://doi.org/10.1145/1999747.1999787
  366. Matti Lattu, Veijo Meisalo, and Jorma Tarhio. 2003. A visualisation tool as a demonstration aid. Computers & Education 41, 2 (2003), 133-148. https: //doi.org/10.1016/S0360-1315(03)00032-0
  367. Celine Latulipe, N. Bruce Long, and Carlos E. Seminario. 2015. Structuring flipped classes with lightweight teams and gamification. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 392-397. https://doi.org/10.1145/2676723.2677240
  368. Tom Lauwers, Illah Nourbakhsh, and Emily Hamner. 2009. CSbots: design and deployment of a robot designed for the CS1 classroom. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 428-432. https://doi.org/10.1145/1508865.1509017
  369. Kris M.Y. Law, Victor C.S. Lee, and Y.T. Yu. 2010. Learning motivation in e- learning facilitated computer programming courses. Computers & Education 55, 1 (2010), 218-228. https://doi.org/10.1016/j.compedu.2010.01.007
  370. Michael J Lee, Faezeh Bahmani, Irwin Kwan, Jilian LaFerte, Polina Charters, Amber Horvath, Fanny Luor, Jill Cao, Catherine Law, Michael Beswetherick, et al. 2014. Principles of a debugging-first puzzle game for computing educa- tion. In IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC 2014). IEEE, 57-64. https://doi.org/10.1109/VLHCC.2014.6883023
  371. Juho Leinonen, Leo Leppänen, Petri Ihantola, and Arto Hellas. 2017. Comparison of time metrics in programming. In Proceedings of the 2017 ACM Conference on International Computing Education Research (ICER '17). ACM, New York, NY, USA, 200-208. https://doi.org/10.1145/3105726.3106181
  372. Noel LeJeune. 2010. Contract grading with mastery learning in CS 1. J. Comput. Sci. Coll. 26, 2 (2010), 149-156. http://dl.acm.org/citation.cfm?id= 1858583.1858604
  373. Ronald Leppan, Charmain Cilliers, and Marinda Taljaard. 2007. Supporting CS1 with a program beacon recognition tool. In Proceedings of the 2007 Annual Research Conference of the South African Institute of Computer Scientists and Information Technologists on IT Research in Developing Countries (SAICSIT '07). ACM, New York, NY, USA, 66-75. https://doi.org/10.1145/ 1292491.1292499
  374. Leo Leppänen, Juho Leinonen, Petri Ihantola, and Arto Hellas. 2017. Predicting academic success based on learning material usage. In Proceedings of the 18th Annual Conference on Information Technology Education (SIGITE '17). ACM, New York, NY, USA, 13-18. https://doi.org/10.1145/3125659.3125695
  375. Chuck Leska and John Rabung. 2005. Refactoring the CS1 course. J. Comput. Sci. Coll. 20, 3 (2005), 6-18. http://dl.acm.org/citation.cfm?id=1040196.1040199
  376. Colleen M. Lewis, Ken Yasuhara, and Ruth E. Anderson. 2011. Deciding to major in computer science: a grounded theory of students' self-assessment of ability. In Proceedings of the Seventh International Workshop on Computing Education Research (ICER '11). ACM, New York, NY, USA, 3-10. https://doi. org/10.1145/2016911.2016915
  377. Hai-Ning Liang, Charles Fleming, Ka Lok Man, and Tammam Tillo. 2013. A first introduction to programming for first-year students at a Chinese university using LEGO MindStorms. In Proceedings of IEEE International Conference on Teaching, Assessment and Learning for Engineering (TALE '13). IEEE, 233-238. https://doi.org/10.1109/TALE.2013.6654435
  378. Soohyun Nam Liao, Daniel Zingaro, Michael A. Laurenzano, William G. Gris- wold, and Leo Porter. 2016. Lightweight, early identification of at-risk CS1 stu- dents. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER '16). ACM, New York, NY, USA, 123-131. https: //doi.org/10.1145/2960310.2960315
  379. Derrell Lipman. 2014. LearnCS!: a new, browser-based C programming envi- ronment for CS1. J. Comput. Sci. Coll. 29, 6 (2014), 144-150. http://dl.acm.org/ citation.cfm?id=2602724.2602752
  380. Alex Lishinski, Aman Yadav, and Richard Enbody. 2017. Students' emotional reactions to programming projects in introduction to programming: measure- ment approach and influence on learning outcomes. In Proceedings of the 2017 ACM Conference on International Computing Education Research (ICER '17). ACM, New York, NY, USA, 30-38. https://doi.org/10.1145/3105726.3106187
  381. Alex Lishinski, Aman Yadav, Richard Enbody, and Jon Good. 2016. The influ- ence of problem solving abilities on students' performance on different assess- ment tasks in CS1. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 329- 334. https://doi.org/10.1145/2839509.2844596
  382. Alex Lishinski, Aman Yadav, Jon Good, and Richard Enbody. 2016. Learn- ing to program: gender differences and interactive effects of students' motiva- tion, goals, and self-efficacy on performance. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER '16). ACM, New York, NY, USA, 211-220. https://doi.org/10.1145/2960310.2960329
  383. Raymond Lister. 2004. Teaching Java first: experiments with a pigs-early ped- agogy. In Proceedings of the Sixth Australasian Conference on Computing Education -Volume 30 (ACE '04). Australian Computer Society, Inc., Dar- linghurst, Australia, Australia, 177-183. http://dl.acm.org/citation.cfm?id= 979968.979992
  384. Raymond Lister. 2005. One small step toward a culture of peer review and multi-institutional sharing of educational resources: a multiple choice exam for first semester programming students. In Proceedings of the 7th Australasian Conference on Computing Education -Volume 42 (ACE '05). Aus- tralian Computer Society, Inc., Darlinghurst, Australia, Australia, 155-164. http://dl.acm.org/citation.cfm?id=1082424.1082444
  385. Raymond Lister. 2011. Concrete and other neo-piagetian forms of reason- ing in the novice programmer. In Proceedings of the Thirteenth Australasian Computing Education Conference -Volume 114 (ACE '11). Australian Com- puter Society, Inc., Darlinghurst, Australia, Australia, 9-18. http://dl.acm.org/ citation.cfm?id=2459936.2459938
  386. Raymond Lister, Elizabeth S Adams, Sue Fitzgerald, William Fone, John Hamer, Morten Lindholm, Robert McCartney, Jan Erik Moström, Kate Sanders, Otto Seppälä, et al. 2004. A multi-national study of reading and tracing skills in novice programmers. In Working Group Reports from ITiCSE on Innovation and Technology in Computer Science Education (ITiCSE-WGR '04). ACM, New York, NY, USA, 119-150. https://doi.org/10.1145/1044550.1041673
  387. Raymond Lister, Colin Fidge, and Donna Teague. 2009. Further evidence of a relationship between explaining, tracing and writing skills in introductory programming. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 161-165. https://doi.org/10.1145/1562877.1562930
  388. Raymond Lister and John Leaney. 2003. Introductory programming, criterion- referencing, and Bloom. In Proceedings of the 34th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '03). ACM, New York, NY, USA, 143-147. https://doi.org/10.1145/611892.611954
  389. Stanislav Litvinov, Marat Mingazov, Vladislav Myachikov, Vladimir Ivanov, Yuliya Palamarchuk, Pavel Sozonov, and Giancarlo Succi. 2017. A tool for visual- izing the execution of programs and stack traces especially suited for novice pro- grammers. In Proceedings of the 12th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE 2017). Springer Interna- tional Publishing, 235-240.
  390. Matija Lokar and Matija Pretnar. 2015. A low overhead automated service for teaching programming. In Proceedings of the 15th Koli Calling Conference on Computing Education Research (Koli Calling '15). ACM, New York, NY, USA, 132-136. https://doi.org/10.1145/2828959.2828964
  391. Dastyni Loksa and Andrew J. Ko. 2016. The role of self-regulation in program- ming problem solving process and success. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER '16). ACM, New York, NY, USA, 83-91. https://doi.org/10.1145/2960310.2960334
  392. Mike Lopez, Jacqueline Whalley, Phil Robbins, and Raymond Lister. 2008. Re- lationships between reading, tracing and writing skills in introductory pro- gramming. In Proceedings of the Fourth International Workshop on Computing Education Research (ICER '08). ACM, New York, NY, USA, 101-112. https: //doi.org/10.1145/1404520.1404531
  393. Ellie Lovellette, John Matta, Dennis Bouvier, and Roger Frye. 2017. Just the numbers: an investigation of contextualization of problems for novice pro- grammers. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 393-398. https://doi.org/10.1145/3017680.3017726
  394. Andrew K. Lui, Yannie H. Y. Cheung, and Siu Cheung Li. 2008. Leveraging students' programming laboratory work as worked examples. SIGCSE Bull. 40, 2 (2008), 69-73. https://doi.org/10.1145/1383602.1383638
  395. Evelyn Lulis and Reva Freedman. 2011. Validating an instructor rating scale for the difficulty of CS1 test items in C++. J. Comput. Sci. Coll. 27, 2 (2011), 85-91. http://dl.acm.org/citation.cfm?id=2038836.2038847
  396. Harri Luoma, Essi Lahtinen, and Hannu-Matti Järvinen. 2007. CLIP, a command line interpreter for a subset of C++. In Proceedings of the Seventh Baltic Sea Conference on Computing Education Research -Volume 88 (Koli Calling '07). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 199-202. http://dl.acm.org/citation.cfm?id=2449323.2449351
  397. Andrew Luxton-Reilly. 2016. Learning to program is easy. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 284-289. https://doi.org/10. 1145/2899415.2899432
  398. Andrew Luxton-Reilly, Brett A. Becker, Yingjun Cao, Roger McDermott, Clau- dio Mirolo, Andreas Mühling, Andrew Petersen, Kate Sanders, Simon, and Jacqueline Whalley. 2017. Developing assessments to determine mastery of programming fundamentals. In Proceedings of the 2017 ITiCSE Conference on Working Group Reports (ITiCSE-WGR '17). ACM, New York, NY, USA, 47-69. https://doi.org/10.1145/3174781.3174784
  399. Andrew Luxton-Reilly and Paul Denny. 2009. A simple framework for interac- tive games in CS1. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 216-220. https://doi.org/10.1145/1508865.1508947
  400. Andrew Luxton-Reilly and Andrew Petersen. 2017. The compound na- ture of novice programming assessments. In Proceedings of the Nineteenth Australasian Computing Education Conference (ACE '17). ACM, New York, NY, USA, 26-35. https://doi.org/10.1145/3013499.3013500
  401. Marianne Lykke, Mayela Coto, Sonia Mora, Niels Vandel, and Christian Jantzen. 2014. Motivating programming students by problem based learning and LEGO robots. In IEEE Global Engineering Education Conference (EDUCON '14). IEEE, 544-555. https://doi.org/10.1109/EDUCON.2014.6826146
  402. Linxiao Ma, John Ferguson, Marc Roper, Isla Ross, and Murray Wood. 2009. Improving the mental models held by novice programmers using cognitive con- flict and Jeliot visualisations. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 166-170. https://doi.org/10.1145/ 1562877.1562931
  403. Linxiao Ma, John Ferguson, Marc Roper, and Murray Wood. 2007. Investigating the viability of mental models held by novice programmers. In Proceedings of the 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '07). ACM, New York, NY, USA, 499-503. https://doi.org/10.1145/ 1227310.1227481
  404. Linxiao Ma, John Ferguson, Marc Roper, and Murray Wood. 2011. Investigating and improving the models of programming concepts held by novice program- mers. Computer Science Education 21, 1 (2011), 57-80. https://doi.org/10.1080/ 08993408.2011.554722
  405. Sandra Madison and James Gifford. 2002. Modular programming: novice miscon- ceptions. Journal of Research on Technology in Education 34, 3 (2002), 217-229. https://doi.org/10.1080/15391523.2002.10782346
  406. Qusay H. Mahmoud, Wlodek Dobosiewicz, and David Swayne. 2004. Re- designing introductory computer programming with HTML, JavaScript, and Java. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 120-124. https: //doi.org/10.1145/971300.971344
  407. Qusay H Mahmoud and Pawel Popowicz. 2010. A mobile application devel- opment approach to teaching introductory programming. In IEEE Frontiers in Education Conference (FIE '10). IEEE, T4F-1-T4F-6. https://doi.org/10.1109/ FIE.2010.5673608
  408. Mirna Carelli Oliveira Maia, Dalton Serey, and Jorge Figueiredo. 2017. Learning styles in programming education: a systematic mapping study. In IEEE Frontiers in Education Conference (FIE '17). IEEE, 1-7. https://doi.org/10.1109/FIE.2017. 8190465
  409. L. Major, T. Kyriacou, and O. P. Brereton. 2012. Systematic literature review: teaching novices programming using robots. In IET Software, Vol. 6. IET, 502- 513. Issue 6. https://doi.org/10.1049/iet-sen.2011.0125
  410. David J. Malan. 2010. Reinventing CS50. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). ACM, New York, NY, USA, 152-156. https://doi.org/10.1145/1734263.1734316
  411. Mercy Maleko, Margaret Hamilton, and Daryl D'Souza. 2012. Novices' per- ceptions and experiences of a mobile social learning environment for learn- ing of programming. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 285-290. https://doi.org/10.1145/2325296.2325364
  412. Mercy Maleko, Dip Nandi, Margaret Hamilton, Daryl D'Souza, and James Har- land. 2013. Facebook versus Blackboard for supporting the learning of pro- gramming in a fully online course: the changing face of computing education. In Learning and Teaching in Computing and Engineering (LaTiCE '13). IEEE, 83-89. https://doi.org/10.1109/LaTiCE.2013.31
  413. Lauri Malmi, Judy Sheard, Simon, Roman Bednarik, Juha Helminen, Päivi Kinnunen, Ari Korhonen, Niko Myller, Juha Sorva, and Ahmad Taherkhani. 2014. Theoretical underpinnings of computing education research: what is the evidence?. In Proceedings of the Tenth Annual Conference on International Computing Education Research (ICER '14). ACM, New York, NY, USA, 27-34. https://doi.org/10.1145/2632320.2632358
  414. Linda Mannila and Michael de Raadt. 2006. An objective comparison of lan- guages for teaching introductory programming. In Proceedings of the 6th Baltic Sea Conference on Computing Education Research: Koli Calling 2006 (Koli Calling '06). ACM, New York, NY, USA, 32-37. https://doi.org/10.1145/ 1315803.1315811
  415. Guillaume Marceau, Kathi Fisler, and Shriram Krishnamurthi. 2011. Mea- suring the effectiveness of error messages designed for novice programmers. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 499-504. https://doi.org/ 10.1145/1953163.1953308
  416. Jakeline Marcos-Abed. 2014. Using a COAC# for CS1. In Proceedings of the Western Canadian Conference on Computing Education (WCCCE '14). ACM, New York, NY, USA, Article 10, 10:1-10:3 pages. https://doi.org/10.1145/2597959. 2597971
  417. Stefanie A. Markham. 2009. Expanding security awareness in introductory computer science courses. In Information Security Curriculum Development Conference (InfoSecCD '09). ACM, New York, NY, USA, 27-31. https://doi.org/ 10.1145/1940976.1940984
  418. Stefanie A. Markham and K. N. King. 2010. Using personal robots in CS1: experiences, outcomes, and attitudinal influences. In Proceedings of the Fifteenth Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '10). ACM, New York, NY, USA, 204-208. https: //doi.org/10.1145/1822090.1822148
  419. Tanya Markow, Eugene Ressler, and Jean Blair. 2006. Catch that speeding turtle: latching onto fun graphics in CS1. Ada Lett. XXVI, 3 (2006), 29-34. https://doi.org/10.1145/1185875.1185648
  420. Will Marrero and Amber Settle. 2005. Testing first: emphasizing testing in early programming courses. In Proceedings of the 10th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '05). ACM, New York, NY, USA, 4-8. https://doi.org/10.1145/1067445.1067451
  421. Chris Martin, Janet Hughes, and John Richards. 2017. Learning experiences in programming: the motivating effect of a physical interface. In Proceedings of the 9th International Conference on Computer Supported Education, Vol. 1. SCITEPRESS, 162-172.
  422. José Alfredo Martínez-Valdés, J. Ángel Velázquez-Iturbide, and Raquel Hijón- Neira. 2017. A (relatively) unsatisfactory experience of use of Scratch in CS1. In Proceedings of the 5th International Conference on Technological Ecosystems for Enhancing Multiculturality (TEEM '17). ACM, New York, NY, USA, Article 8, 8:1-8:7 pages. https://doi.org/10.1145/3144826.3145356
  423. Raina Mason and Simon. 2017. Introductory programming courses in Australasia in 2016. In Proceedings of the Nineteenth Australasian Computing Education Conference (ACE '17). ACM, New York, NY, USA, 81-89. https://doi.org/10. 1145/3013499.3013512
  424. Ásrún Matthíasdóttir and Hallgrímur Arnalds. 2016. E-assessment: students' point of view. In Proceedings of the 17th International Conference on Computer Systems and Technologies (CompSysTech '16). ACM, New York, NY, USA, 369- 374. https://doi.org/10.1145/2983468.2983497
  425. Sarah Matzko and Timothy A. Davis. 2006. Teaching CS1 with graphics and C. In Proceedings of the 11th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITICSE '06). ACM, New York, NY, USA, 168-172. https://doi.org/10.1145/1140124.1140170
  426. Bruce A. Maxwell and Stephanie R. Taylor. 2017. Comparing outcomes across different contexts in CS1. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 399-403. https://doi.org/10.1145/3017680.3017757
  427. Brendan McCane, Claudia Ott, Nick Meek, and Anthony Robins. 2017. Mas- tery learning in introductory programming. In Proceedings of the Nineteenth Australasian Computing Education Conference (ACE '17). ACM, New York, NY, USA, 1-10. https://doi.org/10.1145/3013499.3013501
  428. Renée McCauley, Christopher Starr, Walter Pharr, RoxAnn Stalvey, and George Pothering. 2006. Is CS1 better with the same lecture and lab instructor? SIGCSE Bull. 38, 2 (2006), 54-60. https://doi.org/10.1145/1138403.1138433
  429. Ian McChesney. 2016. Three years of student pair programming: action research insights and outcomes. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 84- 89. https://doi.org/10.1145/2839509.2844565
  430. Michael McCracken, Vicki Almstrum, Danny Diaz, Mark Guzdial, Dianne Hagan, Yifat Ben-David Kolikant, Cary Laxer, Lynda Thomas, Ian Utting, and Tadeusz Wilusz. 2001. A multi-national, multi-institutional study of assessment of programming skills of first-year CS students. In ITiCSE Working Group Reports (ITiCSE-WGR 2001). ACM, New York, NY, USA, 125-180. https://doi.org/10. 1145/572139.572181
  431. Charlie McDowell, Linda Werner, Heather E. Bullock, and Julian Fernald. 2003. The impact of pair programming on student performance, perception and persistence. In Proceedings of the 25th International Conference on Software Engineering (ICSE '03). IEEE Computer Society, Washington, DC, USA, 602-607. http://dl.acm.org/citation.cfm?id=776816.776899
  432. Aidan McGowan, Philip Hanna, and Neil Anderson. 2016. Teaching program- ming: understanding lecture capture YouTube analytics. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 35-40. https://doi.org/10. 1145/2899415.2899421
  433. Fraser McKay and Michael Kölling. 2013. Predictive modelling for HCI prob- lems in novice program editors. In Proceedings of the 27th International BCS Human Computer Interaction Conference (BCS-HCI '13). British Computer So- ciety, Swinton, UK, UK, Article 35, 35:1-35:6 pages. http://dl.acm.org/citation. cfm?id=2578048.2578092
  434. Jim McKeown. 2004. The use of a multimedia lesson to increase novice pro- grammers' understanding of programming array concepts. J. Comput. Sci. Coll. 19, 4 (2004), 39-50. http://dl.acm.org/citation.cfm?id=1050231.1050236
  435. Dawn McKinney and Leo F. Denton. 2004. Houston, we have a problem: there's a leak in the CS1 affective oxygen tank. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 236-239. https://doi.org/10.1145/971300.971386
  436. Dawn McKinney and Leo F. Denton. 2005. Affective assessment of team skills in agile CS1 labs: the good, the bad, and the ugly. In Proceedings of the 36th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '05).
  437. ACM, New York, NY, USA, 465-469. https://doi.org/10.1145/1047344.1047494
  438. Dawn McKinney and Leo F. Denton. 2006. Developing collaborative skills early in the CS curriculum in a laboratory environment. In Proceedings of the 37th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '06).
  439. ACM, New York, NY, USA, 138-142. https://doi.org/10.1145/1121341.1121387
  440. Kirby McMaster, Brian Rague, Samuel Sambasivam, and Stuart Wolthuis. 2016. Coverage of CS1 programming concepts in C++ and Java textbooks. In IEEE Frontiers in Education Conference (FIE '16). IEEE, 1-8. https://doi.org/10.1109/ FIE.2016.7757618
  441. William Isaac McWhorter and Brian C. O'Connor. 2009. Do LEGO® Mind- storms® motivate students in CS1?. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 438-442. https://doi.org/10.1145/1508865.1509019
  442. R. P. Medeiros, G. L. Ramalho, and T. P. Falcão. 2018. A systematic literature review on teaching and learning introductory programming in higher education. IEEE Transactions on Education (2018), 1-14. https://doi.org/10.1109/TE.2018. 2864133
  443. Paola Medel and Vahab Pournaghshband. 2017. Eliminating gender bias in com- puter science education materials. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 411-416. https://doi.org/10.1145/3017680.3017794
  444. M. Dee Medley. 2007. Inquiry-based learning in CS1. J. Comput. Sci. Coll. 23, 2 (2007), 209-215. http://dl.acm.org/citation.cfm?id=1292428.1292464
  445. Andréa Mendonça, Clara de Oliveira, Dalton Guerrero, and Evandro Costa. 2009. Difficulties in solving ill-defined problems: a case study with introductory computer programming students. In IEEE Frontiers in Education Conference (FIE '09). IEEE, 1-6. https://doi.org/10.1109/FIE.2009.5350628
  446. Alexander Mentis, Charles Reynolds, Donald Abbott-McCune, and Benjamin Ring. 2009. Cementing abstraction with a concrete application: a focused use of robots in CS1. In Proceedings of ASEE Annual Conference and Exposition. 14.
  447. László Menyhárt and Gáborné Pap. 2014. Presentation of improved version of guide application for teaching programming fundamentals. In Proceedings on 7th International Multi-Conference on Engineering and Technological Innovation (IMETI '14). IIIS, 77-82.
  448. Michael A. Miljanovic and Jeremy S. Bradbury. 2017. Robobug: a serious game for learning debugging techniques. In Proceedings of the 2017 ACM Conference on International Computing Education Research (ICER '17). ACM, New York, NY, USA, 93-100. https://doi.org/10.1145/3105726.3106173
  449. Alexander Miller, Stuart Reges, and Allison Obourn. 2017. jGRASP: a simple, visual, intuitive programming environment for CS1 and CS2. ACM Inroads 8, 4 (2017), 53-58. https://doi.org/10.1145/3148562
  450. Bradley N. Miller and David L. Ranum. 2012. Beyond PDF and epub: toward an interactive textbook. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 150-155. https://doi.org/10.1145/2325296.2325335
  451. L. D. Miller, Leen-Kiat Soh, Vlad Chiriacescu, Elizabeth Ingraham, Duane F. Shell, and Melissa Patterson Hazley. 2014. Integrating computational and creative thinking to improve learning and performance in CS1. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 475-480. https://doi.org/10.1145/2538862.2538940
  452. Claudio Mirolo. 2012. Is iteration really easier to learn than recursion for CS1 students?. In Proceedings of the Ninth Annual International Conference on International Computing Education Research (ICER '12). ACM, New York, NY, USA, 99-104. https://doi.org/10.1145/2361276.2361296
  453. Ananya Misra, Douglas Blank, and Deepak Kumar. 2009. A music con- text for teaching introductory computing. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 248-252. https://doi.org/10. 1145/1562877.1562955
  454. Behram F.T. Mistree, Bhupesh Chandra, Ewen Cheslack-Postava, Philip Levis, and David Gay. 2011. Emerson: accessible scripting for applications in an ex- tensible virtual world. In Proceedings of the 10th SIGPLAN Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward! 2011). ACM, New York, NY, USA, 77-90. https://doi.org/10.1145/ 2048237.2048247
  455. Phatludi Modiba, Vreda Pieterse, and Bertram Haskins. 2016. Evaluating pla- giarism detection software for introductory programming assignments. In Proceedings of the Computer Science Education Research Conference 2016 (CSERC '16). ACM, New York, NY, USA, 37-46. https://doi.org/10.1145/2998551. 2998558
  456. Susana Montero, Paloma Díaz, David Díez, and Ignacio Aedo. 2010. Dual instructional support materials for introductory object-oriented programming: classes vs. objects. In IEEE Education Engineering Conference (EDUCON '10). IEEE, 1929-1934. https://doi.org/10.1109/EDUCON.2010.5492438
  457. Jan Moons and Carlos De Backer. 2009. Rationale behind the design of the EduVisor software visualization component. Electronic Notes in Theoretical Computer Science 224 (2009), 57-65. https://doi.org/10.1016/j.entcs.2008.12.049
  458. Anmol More, Jitendra Kumar, and VG Renumol. 2011. Web based programming assistance tool for novices. In IEEE International Conference on Technology for Education (T4E '11). IEEE, 270-273. https://doi.org/10.1109/T4E.2011.55
  459. Andrés Moreno, Niko Myller, Erkki Sutinen, and Mordechai Ben-Ari. 2004. Visualizing programs with Jeliot 3. In Proceedings of the Working Conference on Advanced Visual Interfaces (AVI '04). ACM, New York, NY, USA, 373-376. https://doi.org/10.1145/989863.989928
  460. Michael Morgan, Jane Sinclair, Matthew Butler, Neena Thota, Janet Fraser, Gerry Cross, and Jana Jackova. 2017. Understanding international benchmarks on student engagement: awareness and research alignment from a computer science perspective. In Proceedings of the 2017 ITiCSE Conference on Working Group Reports (ITiCSE-WGR '17). ACM, New York, NY, USA, 1-24. https://doi. org/10.1145/3174781.3174782
  461. Sally H. Moritz, Fang Wei, Shahida M. Parvez, and Glenn D. Blank. 2005. From objects-first to design-first with multimedia and intelligent tutoring. In Proceedings of the 10th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '05). ACM, New York, NY, USA, 99-103. https://doi.org/10.1145/1067445.1067475
  462. Barbara Moskal, Deborah Lurie, and Stephen Cooper. 2004. Evaluating the effectiveness of a new instructional approach. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 75-79. https://doi.org/10.1145/971300.971328
  463. Frank Mueller and Antony L. Hosking. 2003. Penumbra: an Eclipse plugin for introductory programming. In Proceedings of the 2003 OOPSLA Workshop on Eclipse Technology eXchange (Eclipse '03). ACM, New York, NY, USA, 65-68. https://doi.org/10.1145/965660.965674
  464. Andreas Mühling, Peter Hubwieser, and Marc Berges. 2015. Dimensions of pro- gramming knowledge. In International Conference on Informatics in Schools: Situation, Evolution, and Perspectives (ISSEP 2015). Springer, Cham, 32-44. https://doi.org/10.1007/978-3-319-25396-1_4
  465. Paul Mullins, Deborah Whitfield, and Michael Conlon. 2009. Using Alice 2.0 as a first language. J. Comput. Sci. Coll. 24, 3 (2009), 136-143. http://dl.acm.org/ citation.cfm?id=1409873.1409900
  466. Jonathan P. Munson and Elizabeth A. Schilling. 2016. Analyzing novice pro- grammers' response to compiler error messages. J. Comput. Sci. Coll. 31, 3 (2016), 53-61. http://dl.acm.org/citation.cfm?id=2835377.2835386
  467. Surya Muntha and Larry Morell. 2006. Adding object-orientation to Genesis. J. Comput. Sci. Coll. 21, 5 (2006), 101-106. http://dl.acm.org/citation.cfm?id= 1127351.1127369
  468. Christian Murphy, Gail Kaiser, Kristin Loveland, and Sahar Hasan. 2009. Retina: helping students and instructors based on observed programming activities. In Proceedings of the 40th ACM Technical Symposium on Computer Science Education (SIGCSE '09). ACM, New York, NY, USA, 178-182. https://doi.org/ 10.1145/1508865.1508929
  469. Christian Murphy, Eunhee Kim, Gail Kaiser, and Adam Cannon. 2008. Back- stop: a tool for debugging runtime errors. In Proceedings of the 39th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '08). ACM, New York, NY, USA, 173-177. https://doi.org/10.1145/1352135.1352193
  470. Laurie Murphy and Lynda Thomas. 2008. Dangers of a fixed mindset: implica- tions of self-theories research for computer science education. In Proceedings of the 13th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '08). ACM, New York, NY, USA, 271-275. https: //doi.org/10.1145/1384271.1384344
  471. Laurie Murphy and David Wolff. 2009. Creating video podcasts for CS1: lessons learned. J. Comput. Sci. Coll. 25, 1 (2009), 152-158. http://dl.acm.org/citation. cfm?id=1619221.1619252
  472. Thomas P. Murtagh. 2007. Squint: barely visible library support for CS1. In Proceedings of the 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '07). ACM, New York, NY, USA, 526-530. https://doi.org/ 10.1145/1227310.1227489
  473. Thomas P. Murtagh. 2007. Weaving CS into CS1: a doubly depth-first approach. In Proceedings of the 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '07). ACM, New York, NY, USA, 336-340. https://doi.org/ 10.1145/1227310.1227429
  474. Greg L. Nelson, Benjamin Xie, and Andrew J. Ko. 2017. Comprehension first: evaluating a novel pedagogy and tutoring system for program trac- ing in CS1. In Proceedings of the 2017 ACM Conference on International Computing Education Research (ICER '17). ACM, New York, NY, USA, 2-11. https://doi.org/10.1145/3105726.3106178
  475. Vicente Lustosa Neto, Roberta Coelho, Larissa Leite, Dalton S. Guerrero, and Andrea P. Mendonça. 2013. POPT: a problem-oriented programming and test- ing approach for novice students. In Proceedings of the 2013 International Conference on Software Engineering (ICSE '13). IEEE Press, Piscataway, NJ, USA, 1099-1108. http://dl.acm.org/citation.cfm?id=2486788.2486939
  476. Paul Neve, Gordon Hunter, David Livingston, and James Orwell. 2012. NoobLab: an intelligent learning environment for teaching programming. In Proceedings of the The 2012 IEEE/WIC/ACM International Joint Conferences on Web Intelligence and Intelligent Agent Technology -Volume 03 (WI-IAT '12). IEEE Computer Society, Washington, DC, USA, 357-361. https://doi.org/10.1109/ WI-IAT.2012.218
  477. Tia Newhall, Lisa Meeden, Andrew Danner, Ameet Soni, Frances Ruiz, and Richard Wicentowski. 2014. A support program for introductory CS courses that improves student performance and retains students from underrepresented groups. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 433-438. https: //doi.org/10.1145/2538862.2538923
  478. Paul Newton and Stuart Shaw. 2014. Validity in educational and psychological assessment. Sage.
  479. Sin Chun Ng, Steven O Choy, Reggie Kwan, and SF Chan. 2005. A web-based envi- ronment to improve teaching and learning of computer programming in distance education. In International Conference on Web-Based Learning (ICWL '05).
  480. Springer, Berlin, Heidelberg, 279-290. https://doi.org/10.1007/11528043_28
  481. Grace Ngai, Winnie W.Y. Lau, Stephen C.F. Chan, and Hong-va Leong. 2010. On the implementation of self-assessment in an introductory programming course. SIGCSE Bull. 41, 4 (2010), 85-89. https://doi.org/10.1145/1709424.1709453
  482. Thuy-Linh Nguyen, Dip Nandi, and Geoff Warburton. 2011. Alice in online and on-campus environments -how well is it received?. In Proceedings of Information Systems Educators Conference (ISECON '11).
  483. Uolevi Nikula, Orlena Gotel, and Jussi Kasurinen. 2011. A motivation guided holistic rehabilitation of the first programming course. Trans. Comput. Educ. 11, 4, Article 24 (2011), 24:1-24:38 pages. https://doi.org/10.1145/2048931.2048935
  484. Uolevi Nikula, Orlena Gotel, and Jussi Kasurinen. 2011. A motivation guided holistic rehabilitation of the first programming course. Trans. Comput. Educ. 11, 4, Article 24 (Nov. 2011), 24:1-24:38 pages. https://doi.org/10.1145/2048931. 2048935
  485. Keith Nolan and Susan Bergin. 2016. The role of anxiety when learning to program: a systematic review of the literature. In Proceedings of the 16th Koli Calling International Conference on Computing Education Research (Koli Calling '16). ACM, New York, NY, USA, 61-70. https://doi.org/10.1145/ 2999541.2999557
  486. Cindy Norris, Frank Barry, James B. Fenwick Jr., Kathryn Reid, and Josh Rountree. 2008. ClockIt: collecting quantitative data on how beginning software developers really work. In Proceedings of the 13th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '08). ACM, New York, NY, USA, 37-41. https://doi.org/10.1145/1384271.1384284
  487. Jeff Offutt, Paul Ammann, Kinga Dobolyi, Chris Kauffmann, Jaime Lester, Upsorn Praphamontripong, Huzefa Rangwala, Sanjeev Setia, Pearl Wang, and Liz White. 2017. A novel self-paced model for teaching programming. In Proceedings of the Fourth ACM Conference on Learning @ Scale (L@S '17). ACM, New York, NY, USA, 177-180. https://doi.org/10.1145/3051457.3053978
  488. Ken Okada, Manabu Sugiura, Yoshiaki Matsuzawa, Megumi Araki, and Hajime Ohiwa. 2008. Programming in Japanese for literacy education. In History of Computing and Education 3 (HCE3). Springer, US, 171-176. https://doi.org/10. 1007/978-0-387-09657-5_12
  489. Osvaldo Luiz Oliveira, Ana Maria Monteiro, and Norton Trevisan Roman. 2013. Can natural language be utilized in the learning of programming fundamentals?. In IEEE Frontiers in Education Conference (FIE '13). IEEE, 1851-1856. https: //doi.org/10.1109/FIE.2013.6685157
  490. Rafael AP Oliveira, Lucas BR Oliveira, Bruno BP Cafeo, and Vinicius HS Durelli. 2015. Evaluation and assessment of effects on exploring mutation testing in programming courses. In IEEE Frontiers in Education Conference (FIE '15). IEEE, 1-9. https://doi.org/10.1109/FIE.2015.7344051
  491. Tihomir Orehovački, Danijel Radošević, and Mladen Konecki. 2012. Accep- tance of Verificator by information science students. In Proceedings of the 34th International Conference on Information Technology Interfaces (ITI '12). IEEE, 223-230. https://doi.org/10.2498/iti.2012.0451
  492. Tihomir Orehovački, Danijel Radošević, and Mladen Konecki. 2014. Per- ceived quality of Verifìcator in teaching programming. In 37th International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO '14). IEEE, 643-648. https://doi.org/10.1109/MIPRO. 2014.6859646
  493. Claudia Ott, Anthony Robins, Patricia Haden, and Kerry Shephard. 2015. Illus- trating performance indicators and course characteristics to support students' self-regulated learning in CS1. Computer Science Education 25, 2 (2015), 174- 198. https://doi.org/10.1080/08993408.2015.1033129
  494. Claudia Ott, Anthony Robins, and Kerry Shephard. 2016. Translating principles of effective feedback for students into the CS1 context. Trans. Comput. Educ. 16, 1, Article 1 (2016), 1:1-1:27 pages. https://doi.org/10.1145/2737596
  495. Özcan Özyurt and Hacer Özyurt. 2016. Using Facebook to enhance learning experiences of students in computer programming at introduction to program- ming and algorithm course. Computer Applications in Engineering Education 24 (2016), 546-554. https://doi.org/10.1002/cae.21730
  496. James Dean Palmer. 2013. Computer Science I with Flare. J. Comput. Sci. Coll. 28, 4 (2013), 94-100. http://dl.acm.org/citation.cfm?id=2458539.2458557
  497. James Dean Palmer, Joseph Flieger, and Eddie Hillenbrand. 2011. JavaGrinder: a web-based platform for teaching early computing skills. In Proceedings of ASEE Annual Conference and Exposition. ASEE, 15.
  498. Andrei Papancea, Jaime Spacco, and David Hovemeyer. 2013. An open plat- form for managing short programming exercises. In Proceedings of the Ninth Annual International ACM Conference on International Computing Education Research (ICER '13). ACM, New York, NY, USA, 47-52. https://doi.org/10.1145/ 2493394.2493401
  499. Sagar Parihar, Ziyaan Dadachanji, Praveen Kumar Singh, Rajdeep Das, Amey Karkare, and Arnab Bhattacharya. 2017. Automatic grading and feedback using program repair for introductory programming courses. In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 92-97. https://doi.org/10. 1145/3059009.3059026
  500. Myung Ah Park. 2010. Designing CS1 as an eye-opening tool to the utility of computer science and a research-initiating tool. J. Comput. Sci. Coll. 25, 4 (2010), 44-51. http://dl.acm.org/citation.cfm?id=1734797.1734805
  501. Kevin R Parker, Thomas A Ottaway, and Joseph T Chao. 2006. Criteria for the selection of a programming language for introductory courses. International Journal of Knowledge and Learning 2, 1-2 (2006), 119-139.
  502. Dale Parsons and Patricia Haden. 2006. Parson's Programming Puzzles: A Fun and Effective Learning Tool for First Programming Courses. In Proceedings of the 8th Australasian Conference on Computing Education -Volume 52 (ACE '06). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 157-163. http://dl.acm.org/citation.cfm?id=1151869.1151890
  503. Jody Paul. 2006. Leveraging students knowledge: introducing CS 1 concepts. J. Comput. Sci. Coll. 22, 1 (2006), 246-252. http://dl.acm.org/citation.cfm?id= 1181811.1181846
  504. Jody Paul. 2006. "What first?" Addressing the critical initial weeks of CS-1. In IEEE Frontiers in Education Conference (FIE '06). IEEE, 1-5. https://doi.org/10. 1109/FIE.2006.322382
  505. Jarred Payne, Vincent Cavé, Raghavan Raman, Mathias Ricken, Robert Cartwright, and Vivek Sarkar. 2011. DrHJ: a lightweight pedagogic IDE for Ha- banero Java. In Proceedings of the 9th International Conference on Principles and Practice of Programming in Java (PPPJ '11). ACM, New York, NY, USA, 147-150. https://doi.org/10.1145/2093157.2093180
  506. Patrick Peachock, Nicholas Iovino, and Bonita Sharif. 2017. Investigating eye movements in natural language and C++ source code -a replication experiment. In International Conference on Augmented Cognition. Springer, Cham, 206- 218. https://doi.org/10.1007/978-3-319-58628-1_17
  507. Janice L. Pearce, Mario Nakazawa, and Scott Heggen. 2015. Improving problem decomposition ability in CS1 through explicit guided inquiry-based instruction. J. Comput. Sci. Coll. 31, 2 (2015), 135-144. http://dl.acm.org/citation.cfm?id= 2831432.2831453
  508. Arnold Pears, Stephen Seidman, Crystal Eney, Päivi Kinnunen, and Lauri Malmi. 2005. Constructing a core literature for computing education research. ACM SIGCSE Bulletin 37, 4 (2005), 152-161.
  509. Arnold Pears, Stephen Seidman, Lauri Malmi, Linda Mannila, Elizabeth Adams, Jens Bennedsen, Marie Devlin, and James Paterson. 2007. A survey of lit- erature on the teaching of introductory programming. In ITiCSE Working Group Reports (ITiCSE-WGR '07). ACM, New York, NY, USA, 204-223. https: //doi.org/10.1145/1345443.1345441
  510. Štefan Pero. 2014. How to detect programming skills of students?. In European Summit on Immersive Education. Springer, 63-72. https://doi.org/10.1007/ 978-3-319-22017-8_6
  511. Markeya S. Peteranetz, Abraham E. Flanigan, Duane F. Shell, and Leen-Kiat Soh. 2016. Perceived instrumentality and career aspirations in CS1 courses: change and relationships with achievement. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER '16). ACM, New York, NY, USA, 13-21. https://doi.org/10.1145/2960310.2960320
  512. Andrew Petersen, Michelle Craig, Jennifer Campbell, and Anya Tafliovich. 2016. Revisiting why students drop CS1. In Proceedings of the 16th Koli Calling International Conference on Computing Education Research (Koli Calling '16). ACM, New York, NY, USA, 71-80. https://doi.org/10.1145/2999541.2999552
  513. Andrew Petersen, Michelle Craig, and Daniel Zingaro. 2011. Reviewing CS1 exam question content. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 631- 636. https://doi.org/10.1145/1953163.1953340
  514. Andrew Petersen, Jaime Spacco, and Arto Vihavainen. 2015. An exploration of error quotient in multiple contexts. In Proceedings of the 15th Koli Calling Conference on Computing Education Research (Koli Calling '15). ACM, New York, NY, USA, 77-86. https://doi.org/10.1145/2828959.2828966
  515. Raymond Pettit, John Homer, Roger Gee, Susan Mengel, and Adam Starbuck. 2015. An empirical study of iterative improvement in programming assignments. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 410-415. https://doi.org/ 10.1145/2676723.2677279
  516. Raymond S. Pettit, John Homer, and Roger Gee. 2017. Do enhanced com- piler error messages help students?: Results inconclusive.. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17). ACM, New York, NY, USA, 465-470. https://doi.org/10.1145/ 3017680.3017768
  517. Andrew M Phelps, Christopher A Egert, and Kevin J Bierre. 2005. MUPPETS: multi-user programming pedagogy for enhancing traditional study: an environ- ment for both upper and lower division students. In IEEE Frontiers in Education Conference (FIE '05). IEEE, S2H-8. https://doi.org/10.1109/FIE.2005.1612247
  518. Phitchaya Mangpo Phothilimthana and Sumukh Sridhara. 2017. High-coverage hint generation for massive courses: do automated hints help CS1 students?. In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 182-187. https://doi.org/10.1145/3059009.3059058
  519. Dinh Dong Phuong, Yusuke Yokota, Fumiko Harada, and Hiromitsu Shi- makawa. 2010. Graining and filling understanding gaps for novice program- mers. In International Conference on Education and Management Technology (ICEMT '10). IEEE, 60-64. https://doi.org/10.1109/ICEMT.2010.5657544
  520. Marco Piccioni, Christian Estler, and Bertrand Meyer. 2014. Spoc-supported introduction to programming. In Proceedings of the 2014 Conference on Innovation & Technology in Computer Science Education (ITiCSE '14). ACM, New York, NY, USA, 3-8. https://doi.org/10.1145/2591708.2591759
  521. Chris Piech, Mehran Sahami, Daphne Koller, Steve Cooper, and Paulo Blik- stein. 2012. Modeling how students learn to program. In Proceedings of the 43rd ACM Technical Symposium on Computer Science Education (SIGCSE '12). ACM, New York, NY, USA, 153-160. https://doi.org/10.1145/2157136.2157182
  522. Kerttu Pollari-Malmi, Julio Guerra, Peter Brusilovsky, Lauri Malmi, and Teemu Sirkiä. 2017. On the value of using an interactive electronic textbook in an introductory programming course. In Proceedings of the 17th Koli Calling International Conference on Computing Education Research (Koli Calling '17). ACM, New York, NY, USA, 168-172. https://doi.org/10.1145/3141880.3141890
  523. M. Poole. 2017. Extending the design of a blocks-based Python environment to support complex types. In IEEE Blocks and Beyond Workshop (B&B '17). IEEE, 1-7. https://doi.org/10.1109/BLOCKS.2017.8120400
  524. Leo Porter, Dennis Bouvier, Quintin Cutts, Scott Grissom, Cynthia Lee, Robert McCartney, Daniel Zingaro, and Beth Simon. 2016. A multi-institutional study of peer instruction in introductory computing. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 358-363. https://doi.org/10.1145/2839509.2844642
  525. Leo Porter, Mark Guzdial, Charlie McDowell, and Beth Simon. 2013. Success in introductory programming: what works? Commun. ACM 56, 8 (2013), 34-36. https://doi.org/10.1145/2492007.2492020
  526. Leo Porter and Beth Simon. 2013. Retaining nearly one-third more majors with a trio of instructional best practices in CS1. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 165-170. https://doi.org/10.1145/2445196.2445248
  527. Leo Porter and Daniel Zingaro. 2014. Importance of early performance in CS1: two conflicting assessment stories. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 295-300. https://doi.org/10.1145/2538862.2538912
  528. Leo Porter, Daniel Zingaro, and Raymond Lister. 2014. Predicting student success using fine grain clicker data. In Proceedings of the Tenth Annual Conference on International Computing Education Research (ICER '14). ACM, New York, NY, USA, 51-58. https://doi.org/10.1145/2632320.2632354
  529. Vahab Pournaghshband. 2013. Teaching the security mindset to CS1 students. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 347-352. https://doi.org/ 10.1145/2445196.2445299
  530. Kris Powers, Stacey Ecott, and Leanne M. Hirshfield. 2007. Through the looking glass: teaching CS0 with alice. In Proceedings of the 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '07). ACM, New York, NY, USA, 213-217. https://doi.org/10.1145/1227310.1227386
  531. Kellie Price and Suzanne Smith. 2014. Improving student performance in CS1. J. Comput. Sci. Coll. 30, 2 (2014), 157-163. http://dl.acm.org/citation.cfm?id= 2667432.2667454
  532. Thomas W. Price and Tiffany Barnes. 2015. Comparing textual and block interfaces in a novice programming environment. In Proceedings of the Eleventh Annual International Conference on International Computing Education Research (ICER '15). ACM, New York, NY, USA, 91-99. https://doi. org/10.1145/2787622.2787712
  533. Mitchell Pryor. 2012. Real-time monitoring of student procrastination in a PSI first-year programming course. In Proceedings of ASEE Annual Conference and Exposition. ASEE, 14.
  534. Wayne Pullan, Steven Drew, and Steven Tucker. 2013. An integrated approach to teaching introductory programming. In Second International Conference on E-Learning and E-Technologies in Education (ICEEE '13). IEEE, 81-86. https: //doi.org/10.1109/ICeLeTE.2013.6644352
  535. William Punch, Richard Enbody, Colleen McDonough, and Jon Sticklen. 2010. Measuring the effect of intervening early for academically at risk students in a CS1 course. ASEE.
  536. Sandeep Purao, Maung Sein, Hallgeir Nilsen, and Even Åby Larsen. 2017. Setting the pace: experiments with Keller's PSI. IEEE Transactions on Education 60 (2017), 97-104. Issue 2. https://doi.org/10.1109/TE.2016.2588460
  537. Yizhou Qian and James Lehman. 2017. Students' misconceptions and other diffi- culties in introductory programming: a literature review. ACM Trans. Comput. Educ. 18, 1, Article 1 (2017), 1:1-1:24 pages. https://doi.org/10.1145/3077618
  538. Keith Quille, Natalie Culligan, and Susan Bergin. 2017. Insights on gender differences in CS1: a multi-institutional, multi-variate study.. In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 263-268. https://doi.org/10. 1145/3059009.3059048
  539. Martin Quinson and Gérald Oster. 2015. A teaching system to learn program- ming: the programmer's learning machine. In Proceedings of the 2015 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '15). ACM, New York, NY, USA, 260-265. https://doi.org/10.1145/ 2729094.2742626
  540. Alex Radermacher, Gursimran Walia, and Richard Rummelt. 2012. Assigning student programming pairs based on their mental model consistency: an ini- tial investigation. In Proceedings of the 43rd ACM Technical Symposium on Computer Science Education (SIGCSE '12). ACM, New York, NY, USA, 325-330. https://doi.org/10.1145/2157136.2157236
  541. Alex D. Radermacher and Gursimran S. Walia. 2011. Investigating the ef- fective implementation of pair programming: an empirical investigation. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 655-660. https://doi.org/ 10.1145/1953163.1953346
  542. Teemu Rajala, Mikko-Jussi Laakso, Erkki Kaila, and Tapio Salakoski. 2007. VILLE: a language-independent program visualization tool. In Proceedings of the Seventh Baltic Sea Conference on Computing Education Research -Volume 88 (Koli Calling '07). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 151-159. http://dl.acm.org/citation.cfm?id=2449323.2449340
  543. R.Z. Ramli, A.Y. Kapi, and N. Osman. 2015. Visualization makes array easy. In Proceedings of the 2015 International Conference on Testing and Measurement: Techniques and Applications (TMTA '15). CRC Press, 381-384.
  544. Justus J Randolph, George Julnes, Erkki Sutinen, and Steve Lehman. 2008. A methodological review of computer science education research. Journal of Information Technology Education: Research 7 (2008), 135-162.
  545. R. Rashkovits and I. Lavy. 2011. Students' strategies for exception handling. Journal of Information Technology Education: Research 10, 1 (2011), 183-207. https://doi.org/10.28945/1500
  546. Andrew Ray. 2012. Evolving the usage of LEGO robots in CS1 to facilitate high- level problem solving. In Proceedings of the IASTED International Conference on Computers and Advanced Technology in Education (CATE '12). ICTA Press, 91-98. https://doi.org/10.2316/P.2012.774-034
  547. Saquib Razak. 2013. A case for course capstone projects in CS1. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 693-698. https://doi.org/10.1145/ 2445196.2445398
  548. Susan Reardon and Brendan Tangney. 2014. Smartphones, studio-based learning, and scaffolding: helping novices learn to program. Trans. Comput. Educ. 14, 4, Article 23 (2014), 23:1-23:15 pages. https://doi.org/10.1145/2677089
  549. Samuel A. Rebelsky, Janet Davis, and Jerod Weinman. 2013. Building knowledge and confidence with mediascripting: a successful interdisciplinary approach to CS1. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 483-488. https: //doi.org/10.1145/2445196.2445342
  550. Dale Reed, Sam John, Ryan Aviles, and Feihong Hsu. 2004. CFX: finding just the right examples for CS1. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 363-367. https://doi.org/10.1145/971300.971426
  551. Stuart Reges. 2006. Back to basics in CS1 and CS2. SIGCSE Bull. 38, 1 (2006), 293-297. https://doi.org/10.1145/1124706.1121432
  552. Charles Reis and Robert Cartwright. 2004. Taming a professional IDE for the classroom. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 156-160. https://doi.org/10.1145/971300.971357
  553. Jake Renzella and Andrew Cain. 2017. Supporting better formative feedback in task-oriented portfolio assessment. In IEEE 6th International Conference on Teaching, Assessment, and Learning for Engineering (TALE '17). IEEE, 360-367. https://doi.org/10.1109/TALE.2017.8252362
  554. Emma Riese. 2017. Students' experience and use of assessment in an online introductory programming course. In International Conference on Learning and Teaching in Computing and Engineering (LaTiCE '17). IEEE, 30-34. https: //doi.org/10.1109/LaTiCE.2017.13
  555. Peter C. Rigby and Suzanne Thompson. 2005. Study of novice programmers using Eclipse and Gild. In Proceedings of the 2005 OOPSLA Workshop on Eclipse Technology eXchange (Eclipse '05). ACM, New York, NY, USA, 105-109. https://doi.org/10.1145/1117696.1117718
  556. Kelly Rivers and Kenneth R. Koedinger. 2015. Data-driven hint generation in vast solution spaces: a self-improving Python programming tutor. International Journal of Artificial Intelligence in Education 27, 1 (2015), 37-64. https://doi. org/10.1007/s40593-015-0070-z
  557. Mona Rizvi, Thorna Humphries, Debra Major, Heather Lauzun, and Meghan Jones. 2011. A new CS0 course for at-risk majors. In 24th IEEE-CS Conference on Software Engineering Education and Training (CSEE&T '11). IEEE, 314-323. https://doi.org/10.1109/CSEET.2011.5876101
  558. Eric Roberts and Keith Schwarz. 2013. A portable graphics library for intro- ductory CS. In Proceedings of the 18th ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '13). ACM, New York, NY, USA, 153-158. https://doi.org/10.1145/2462476.2465590
  559. Michael Robey, Brian R Von Konsky, Jim Ivins, Susan J Gribble, Allan Loh, and David Cooper. 2006. Student self-motivation: lessons learned from teaching first year computing. In IEEE Frontiers in Education Conference (FIE '06). IEEE, 6-11. https://doi.org/10.1109/FIE.2006.322363
  560. Anthony Robins. 2010. Learning edge momentum: a new account of outcomes in CS1. Computer Science Education 20, 1 (2010), 37-71. https://doi.org/10. 1080/08993401003612167
  561. Anthony Robins, Janet Rountree, and Nathan Rountree. 2003. Learning and teaching programming: a review and discussion. Computer Science Education 13, 2 (2003), 137-172. https://doi.org/10.1076/csed.13.2.137.14200
  562. Ma. Mercedes T. Rodrigo and Ryan S.J.d. Baker. 2009. Coarse-grained detection of student frustration in an introductory programming course. In Proceedings of the Fifth International Workshop on Computing Education Research Workshop (ICER '09). ACM, New York, NY, USA, 75-80. https://doi.org/10.1145/1584322. 1584332
  563. Ma. Mercedes T. Rodrigo, Ryan S. Baker, Matthew C. Jadud, Anna Chris- tine M. Amarra, Thomas Dy, Maria Beatriz V. Espejo-Lahoz, Sheryl Ann L. Lim, Sheila A.M.S. Pascua, Jessica O. Sugay, and Emily S. Tabanao. 2009. Affective and behavioral predictors of novice programmer achievement. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 156-160. https://doi.org/10.1145/1562877.1562929
  564. Maria Mercedes T Rodrigo, Emily Tabanao, Ma Beatriz E Lahoz, and Matthew C Jadud. 2009. Analyzing online protocols to characterize novice Java program- mers. Philippine Journal of Science 138, 2 (2009), 177-190.
  565. Reinout Roels, Paul Meştereagă, and Beat Signer. 2016. An interactive source code visualisation plug-in for the MindXpres presentation platform. In Communications in Computer and Information Science. Springer, Cham, 169- 188. https://doi.org/10.1007/978-3-319-29585-5_10
  566. Reinout Roels, Paul Meźtereagź, and Beat Signer. 2015. Towards enhanced presentation-based teaching of programming: an interactive source code vi- sualisation approach. In Proceedings of the 7th International Conference on Computer Supported Education-Volume 1 (CSEDU '15). SciTePress, 98-107.
  567. Timo Rongas, Arto Kaarna, and Heikki Kalviainen. 2004. Classification of com- puterized learning tools for introductory programming courses: learning ap- proach. In IEEE International Conference on Advanced Learning Technologies (ICALT '04). IEEE, 678-680. https://doi.org/10.1109/ICALT.2004.1357618
  568. Guido Rößling. 2010. A family of tools for supporting the learning of program- ming. Algorithms 3, 2 (2010), 168-182. https://doi.org/10.3390/a3020168
  569. Janet Rountree, Nathan Rountree, Anthony Robins, and Robert Hannah. 2005. Observations of student competency in a CS1 course. In Proceedings of the 7th Australasian Conference on Computing Education -Volume 42 (ACE '05). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 145-149. http://dl.acm.org/citation.cfm?id=1082424.1082442
  570. Krishnendu Roy, William C Rousse, and David B DeMeritt. 2012. Comparing the mobile novice programming environments: App Inventor for Android vs. GameSalad. In IEEE Frontiers in Education Conference (FIE '12). IEEE, 1-6. https://doi.org/10.1109/FIE.2012.6462363
  571. Marc J. Rubin. 2013. The effectiveness of live-coding to teach introduc- tory programming. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 651-656. https://doi.org/10.1145/2445196.2445388
  572. Miguel Angel Rubio, Rocio Romero-Zaliz, Carolina Mañoso, and P Angel. 2014. Enhancing an introductory programming course with physical com- puting modules. In IEEE Frontiers in Education Conference (FIE '14). IEEE, 1-8. https://doi.org/10.1109/FIE.2014.7044153
  573. Mark F. Russo. 2017. Doodlepad: next-gen event-driven programming for CS1. J. Comput. Sci. Coll. 32, 4 (2017), 99-105. http://dl.acm.org/citation.cfm?id= 3055338.3055356
  574. Daisuke Saito, Ayana Sasaki, Hironori Washizaki, Yoshiaki Fukazawa, and Yusuke Muto. 2017. Program learning for beginners: survey and taxonomy of pro- gramming learning tools. In IEEE 9th International Conference on Engineering Education (ICEED '17). IEEE, 137-142. https://doi.org/10.1109/ICEED.2017. 8251181
  575. A Sajana, Kamal Bijlani, and R Jayakrishnan. 2015. An interactive seri- ous game via visualization of real life scenarios to learn programming con- cepts. In 6th International Conference on Computing, Communication and Networking Technologies (ICCCNT) (ICCCNT '15). IEEE, 1-8. https://doi.org/ 10.1109/ICCCNT.2015.7395173
  576. Norsaremah Salleh, Emilia Mendes, John Grundy, and Giles St. J. Burch. 2010. The effects of neuroticism on pair programming: an empirical study in the higher education context. In Proceedings of the 2010 ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM '10). ACM, New York, NY, USA, Article 22, 22:1-22:10 pages. https://doi.org/10.1145/ 1852786.1852816
  577. Norsaremah Salleh, Emilia Mendes, John Grundy, and Giles St. J Burch. 2010. An empirical study of the effects of conscientiousness in pair programming using the five-factor personality model. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering -Volume 1 (ICSE '10).
  578. ACM, New York, NY, USA, 577-586. https://doi.org/10.1145/1806799.1806883
  579. Dean Sanders and Brian Dorn. 2003. Jeroo: a tool for introducing object-oriented programming. In Proceedings of the 34th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '03). ACM, New York, NY, USA, 201-204. https://doi.org/10.1145/611892.611968
  580. Joseph P. Sanford, Aaron Tietz, Saad Farooq, Samuel Guyer, and R. Benjamin Shapiro. 2014. Metaphors we teach by. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 585-590. https://doi.org/10.1145/2538862.2538945
  581. Loé Sanou, Sybille Caffiau, Patrick Girard, and Laurent Guittet. 2008. Example us- age evaluation for the learning of programming using the MELBA environment. In IADIS Multi Conference on Computer Science and Information Systems; Proceedings of Interfaces and Human Computer Interaction 2008 (MCCSIS '08).
  582. André L. Santos. 2012. An open-ended environment for teaching Java in con- text. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 87-92. https://doi.org/10.1145/2325296.2325320
  583. Linda J. Sax, Kathleen J. Lehman, and Christina Zavala. 2017. Examining the en- rollment growth: non-cs majors in CS1 courses. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education (SIGCSE '17).
  584. ACM, New York, NY, USA, 513-518. https://doi.org/10.1145/3017680.3017781
  585. Pablo Schoeffel, Raul Sidnei Wazlawick, and Vinicius Ramos. 2017. Impact of pre- university factors on the motivation and performance of undergraduate students in software engineering. In IEEE 30th Conference on Software Engineering Education and Training (CSEE&T '17). IEEE, 266-275. https://doi.org/10.1109/ CSEET.2017.50
  586. Joachim Schramm, Sven Strickroth, Nguyen-Thinh Le, and Niels Pinkwart. 2012. Teaching UML skills to novice programmers using a sample solution based intelligent tutoring system. In Proceedings of the 25th International Florida Artificial Intelligence Research Society Conference (FLAIRS '12). AAAI Press, 472-477.
  587. Ivonne Schröter, Jacob Krüger, Janet Siegmund, and Thomas Leich. 2017. Com- prehending studies on program comprehension. In Proceedings of the 25th International Conference on Program Comprehension (ICPC '17). IEEE Press, Piscataway, NJ, USA, 308-311. https://doi.org/10.1109/ICPC.2017.9
  588. Carsten Schulte and Jens Bennedsen. 2006. What do teachers teach in introduc- tory programming?. In Proceedings of the Second International Workshop on Computing Education Research (ICER '06). ACM, New York, NY, USA, 17-28. https://doi.org/10.1145/1151588.1151593
  589. Jorg Schulze, Matthias Langrich, and Antje Meyer. 2007. The success of the demidovich-principle in undergraduate C# programming education. In IEEE Frontiers In Education Conference (FIE '07). IEEE, F4C-7-F4C-12. https://doi. org/10.1109/FIE.2007.4418090
  590. Andrew Scott, Mike Watkins, and Duncan McPhee. 2008. E-learning for novice programmers; a dynamic visualisation and problem solving tool. In 3rd International Conference on Information and Communication Technologies: From Theory to Applications (ICTTA '08). IEEE, 1-6. https://doi.org/10.1109/ ICTTA.2008.4529966
  591. Michael James Scott, Steve Counsell, Stanislao Lauria, Stephen Swift, Allan Tucker, Martin Shepperd, and Gheorghita Ghinea. 2015. Enhancing practice and achievement in introductory programming with a robot Olympics. IEEE Transactions on Education 58 (2015), 249-254. Issue 4. https://doi.org/10.1109/ TE.2014.2382567
  592. Michael James Scott and Gheorghita Ghinea. 2014. Measuring enrichment: the assembly and validation of an instrument to assess student self-beliefs in CS1. In Proceedings of the Tenth Annual Conference on International Computing Education Research (ICER '14). ACM, New York, NY, USA, 123-130. https: //doi.org/10.1145/2632320.2632350
  593. Michael J Scott and Gheorghita Ghinea. 2014. On the domain-specificity of mindsets: the relationship between aptitude beliefs and programming practice. IEEE Transactions on Education 57 (2014), 169-174. Issue 3. https://doi.org/10. 1109/TE.2013.2288700
  594. P. Seeling. 2016. Switching to blend-Ed: effects of replacing the textbook with the browser in an introductory computer programming course. In IEEE Frontiers in Education Conference (FIE '16). IEEE, 1-5. https://doi.org/10.1109/FIE.2016. 7757620
  595. Otto Seppälä, Petri Ihantola, Essi Isohanni, Juha Sorva, and Arto Vihavainen. 2015. Do we know how difficult the rainfall problem is?. In Proceedings of the 15th Koli Calling Conference on Computing Education Research (Koli Calling '15). ACM, New York, NY, USA, 87-96. https://doi.org/10.1145/ 2828959.2828963
  596. Amber Settle, John Lalor, and Theresa Steinbach. 2015. Reconsidering the impact of CS1 on novice attitudes. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 229-234. https://doi.org/10.1145/2676723.2677235
  597. Olga Shabalina, Christos Malliarakis, Florica Tomos, and Peter Mozelius. 2017. Game-based learning for learning to program: from learning through play to learning through game development. In European Conference on Games Based Learning 2017 (ECGBL '17), Vol. 11. Academic Conferences and Publishing International Limited, 571-576.
  598. Steven C. Shaffer and Mary Beth Rosson. 2013. Increasing student success by modifying course delivery based on student submission data. ACM Inroads 4, 4 (2013), 81-86. https://doi.org/10.1145/2537753.2537778
  599. Ritu Sharma, Haifeng Shen, and Robert Goodwin. 2016. Voluntary participation in discussion forums as an engagement indicator: an empirical study of teaching first-year programming. In Proceedings of the 28th Australian Conference on Computer-Human Interaction (OzCHI '16). ACM, New York, NY, USA, 489-493. https://doi.org/10.1145/3010915.3010967
  600. Jason H Sharp and Leah A Schultz. 2013. An exploratory study of the use of video as an instructional tool in an introductory C# programming course. Information Systems Education Journal 11, 6 (2013), 33.
  601. Alan Shaw. 2011. Using a collaborative programming methodology to incorpo- rate social computing projects into introductory computer science courses. In Eighth International Conference on Information Technology: New Generations (ITNG '11). IEEE, 7-11. https://doi.org/10.1109/ITNG.2011.9
  602. Judy Sheard, Angela Carbone, Raymond Lister, Beth Simon, Errol Thompson, and Jacqueline L. Whalley. 2008. Going SOLO to assess novice programmers. In Proceedings of the 13th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '08). ACM, New York, NY, USA, 209-213. https://doi.org/10.1145/1384271.1384328
  603. Judy Sheard, Simon, Matthew Butler, Katrina Falkner, Michael Morgan, and Amali Weerasinghe. 2017. Strategies for maintaining academic integrity in first-year computing courses. In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 244-249. https://doi.org/10.1145/3059009.3059064
  604. Judy Sheard, Simon, Angela Carbone, Donald Chinn, Tony Clear, Malcolm Cor- ney, Daryl D'Souza, Joel Fenwick, James Harland, Mikko-Jussi Laakso, and Donna Teague. 2013. How difficult are exams?: a framework for assessing the complexity of introductory programming exams. In Proceedings of the Fifteenth Australasian Computing Education Conference -Volume 136 (ACE '13). Aus- tralian Computer Society, Inc., Darlinghurst, Australia, Australia, 145-154. http://dl.acm.org/citation.cfm?id=2667199.2667215
  605. Judy Sheard, Simon, Angela Carbone, Daryl D'Souza, and Margaret Hamil- ton. 2013. Assessment of programming: pedagogical foundations of exams. In Proceedings of the 18th ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '13). ACM, New York, NY, USA, 141-146. https://doi.org/10.1145/2462476.2465586
  606. Judy Sheard, Simon, Julian Dermoudy, Daryl D'Souza, Minjie Hu, and Dale Par- sons. 2014. Benchmarking a set of exam questions for introductory programming. In Proceedings of the Sixteenth Australasian Computing Education Conference -Volume 148 (ACE '14). Australian Computer Society, Inc., Darlinghurst, Aus- tralia, Australia, 113-121. http://dl.acm.org/citation.cfm?id=2667490.2667504
  607. Judy Sheard, Simon, Margaret Hamilton, and Jan Lönnberg. 2009. Analysis of research into the teaching and learning of programming. In Proceedings of the Fifth International Workshop on Computing Education Research Workshop (ICER '09). ACM, New York, NY, USA, 93-104. https://doi.org/10.1145/1584322. 1584334
  608. Lee Sheldon. 2011. The multiplayer classroom: designing coursework as a game. Cengage Learning.
  609. Duane F. Shell, Leen-Kiat Soh, Abraham E. Flanigan, and Markeya S. Peteranetz. 2016. Students' initial course motivation and their achievement and retention in college CS1 courses. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 639- 644. https://doi.org/10.1145/2839509.2844606
  610. Nianfeng Shi, Zhiyu Min, and Ping Zhang. 2017. Effects of visualizing roles of variables with animation and IDE in novice program construction. Telematics and Informatics 34, 5 (2017), 743-754. https://doi.org/10.1016/j.tele.2017.02.005
  611. Dermot Shinners-Kennedy and David J. Barnes. 2011. The novice programmer's "device to think with". In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 511- 516. https://doi.org/10.1145/1953163.1953310
  612. Shuhaida Shuhidan, Margaret Hamilton, and Daryl D'Souza. 2009. A taxo- nomic study of novice programming summative assessment. In Proceedings of the Eleventh Australasian Conference on Computing Education -Volume 95 (ACE '09). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 147-156. http://dl.acm.org/citation.cfm?id=1862712.1862734
  613. T. Y. Sim. 2015. Exploration on the impact of online supported methods for novice programmers. In IEEE Conference on e-Learning, e-Management and e-Services (IC3e) (IC3e '15). IEEE, 158-162. https://doi.org/10.1109/IC3e.2015. 7403505
  614. Simon. 2011. Assignment and sequence: why some students can't recognise a simple swap. In Proceedings of the 11th Koli Calling International Conference on Computing Education Research (Koli Calling '11). ACM, New York, NY, USA, 10-15. https://doi.org/10.1145/2094131.2094134
  615. Simon. 2013. Soloway's rainfall problem has become harder. In Learning and Teaching in Computing and Engineering (LaTiCE '13). IEEE, 130-135. https: //doi.org/10.1109/LaTiCE.2013.44
  616. Simon, Angela Carbone, Michael de Raadt, Raymond Lister, Margaret Hamilton, and Judy Sheard. 2008. Classifying computing education papers: process and results. In Proceedings of the Fourth International Workshop on Computing Education Research (ICER '08). ACM, New York, NY, USA, 161-172. https: //doi.org/10.1145/1404520.1404536
  617. Simon, Donald Chinn, Michael de Raadt, Anne Philpott, Judy Sheard, Mikko- Jussi Laakso, Daryl D'Souza, James Skene, Angela Carbone, Tony Clear, Ray- mond Lister, and Geoff Warburton. 2012. Introductory programming: exam- ining the exams. In Proceedings of the Fourteenth Australasian Computing Education Conference -Volume 123 (ACE '12). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 61-70. http://dl.acm.org/citation.cfm? id=2483716.2483724
  618. Simon, Alison Clear, Janet Carter, Gerry Cross, Atanas Radenski, Liviana Tudor, and Eno Tõnisson. 2015. What's in a Name?: International Interpretations of Computing Education Terminology. In Proceedings of the 2015 ITiCSE on Working Group Reports (ITICSE-WGR '15). ACM, New York, NY, USA, 173-186. https://doi.org/10.1145/2858796.2858803
  619. Simon, Daryl D'Souza, Judy Sheard, James Harland, Angela Carbone, and Mikko-Jussi Laakso. 2012. Can computing academics assess the difficulty of programming examination questions?. In Proceedings of the 12th Koli Calling International Conference on Computing Education Research (Koli Calling '12). ACM, New York, NY, USA, 160-163. https://doi.org/10.1145/2401796.2401822
  620. Simon, Mike Lopez, Ken Sutton, and Tony Clear. 2009. Surely we must learn to read before we learn to write!. In Proceedings of the Eleventh Australasian Conference on Computing Education -Volume 95 (ACE '09). Australian Com- puter Society, Inc., Darlinghurst, Australia, Australia, 165-170. http://dl.acm. org/citation.cfm?id=1862712.1862736
  621. Simon, Judy Sheard, Daryl D'Souza, Peter Klemperer, Leo Porter, Juha Sorva, Martijn Stegeman, and Daniel Zingaro. 2016. Benchmarking introductory pro- gramming exams: how and why. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '16). ACM, New York, NY, USA, 154-159. https://doi.org/10.1145/2899415.2899473
  622. Simon, Judy Sheard, Daryl D'Souza, Peter Klemperer, Leo Porter, Juha Sorva, Martijn Stegeman, and Daniel Zingaro. 2016. Benchmarking introductory programming exams: some preliminary results. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER '16). ACM, New York, NY, USA, 103-111. https://doi.org/10.1145/2960310.2960337
  623. Simon, Judy Sheard, Michael Morgan, Andrew Petersen, Amber Settle, Jane Sinclair, Gerry Cross, and Charles Riedesel. 2016. Negotiating the maze of academic integroty in computing education. In ITiCSE Working Group Reports (ITiCSE-WGR '16). ACM, New York, NY, USA, 57-80. https://doi.org/10.1145/ 3024906.3024910
  624. Beth Simon, Sue Fitzgerald, Renée McCauley, Susan Haller, John Hamer, Brian Hanks, Michael T. Helmick, Jan Erik Moström, Judy Sheard, and Lynda Thomas. 2007. Debugging assistance for novices: a video repository. In Working Group Reports on ITiCSE on Innovation and Technology in Computer Science Education (ITiCSE-WGR '07). ACM, New York, NY, USA, 137-151. https: //doi.org/10.1145/1345443.1345437
  625. Beth Simon, Brian Hanks, Laurie Murphy, Sue Fitzgerald, Renée McCauley, Lynda Thomas, and Carol Zander. 2008. Saying isn't necessarily believing: influ- encing self-theories in computing. In Proceedings of the Fourth International Workshop on Computing Education Research (ICER '08). ACM, New York, NY, USA, 173-184. https://doi.org/10.1145/1404520.1404537
  626. Beth Simon, Päivi Kinnunen, Leo Porter, and Dov Zazkis. 2010. Experi- ence report: CS1 for majors with media computation. In Proceedings of the Fifteenth Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '10). ACM, New York, NY, USA, 214-218. https: //doi.org/10.1145/1822090.1822151
  627. Guttorm Sindre, Steinar Line, and Ottar V. Valvåg. 2003. Positive experiences with an open project assignment in an introductory programming course. In Proceedings of the 25th International Conference on Software Engineering (ICSE '03). IEEE Computer Society, Washington, DC, USA, 608-613. http: //dl.acm.org/citation.cfm?id=776816.776900
  628. Rishabh Singh, Sumit Gulwani, and Armando Solar-Lezama. 2013. Automated feedback generation for introductory programming assignments. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI '13). ACM, New York, NY, USA, 15-26. https://doi.org/ 10.1145/2491956.2462195
  629. Teemu Sirkiä. 2016. Jsvee & Kelmu: creating and tailoring program ani- mations for computing education. In IEEE Working Conference on Software Visualization (VISSOFT '16). IEEE, 36-45. https://doi.org/10.1109/VISSOFT. 2016.24
  630. Ben Skudder and Andrew Luxton-Reilly. 2014. Worked examples in computer science. In Proceedings of the Sixteenth Australasian Computing Education Conference -Volume 148 (ACE '14). Australian Computer Society, Inc., Dar- linghurst, Australia, Australia, 59-64. http://dl.acm.org/citation.cfm?id=2667490. 2667497
  631. Robert H. Sloan, Cynthia Taylor, and Richard Warner. 2017. Initial experiences with a CS + Law introduction to computer science (CS 1). In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 40-45. https://doi.org/10. 1145/3059009.3059029
  632. Leen-Kiat Soh. 2006. Incorporating an intelligent tutoring system into CS1. In Proceedings of the 37th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '06). ACM, New York, NY, USA, 486-490. https://doi.org/ 10.1145/1121341.1121494
  633. Elliot Soloway. 1986. Learning to program = learning to construct mechanisms and explanations. Commun. ACM 29, 9 (1986), 850-858.
  634. Hosung Song. 2010. Online shared editing for introductory program- ming courses. In Proceedings of 2nd International Conference on Computer Supported Education -Volume 1 (CSEDU '10), Vol. 1. INSTICC, SciTePress, 489-492. https://doi.org/10.5220/0002860904890492
  635. Raja Sooriamurthi. 2009. Introducing abstraction and decomposition to novice programmers. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 196-200. https://doi.org/10.1145/1562877.1562939
  636. Juha Sorva. 2007. Students' understandings of storing objects. In Proceedings of the Seventh Baltic Sea Conference on Computing Education Research -Volume 88 (Koli Calling '07). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 127-135. http://dl.acm.org/citation.cfm?id=2449323.2449337
  637. Juha Sorva. 2008. The same but different students' understandings of primi- tive and object variables. In Proceedings of the 8th Koli Calling International Conference on Computing Education Research (Koli Calling '08). ACM, New York, NY, USA, 5-15. https://doi.org/10.1145/1595356.1595360
  638. Juha Sorva. 2010. Reflections on threshold concepts in computer programming and beyond. In Proceedings of the 10th Koli Calling International Conference on Computing Education Research (Koli Calling '10). ACM, New York, NY, USA, 21-30. https://doi.org/10.1145/1930464.1930467
  639. Juha Sorva. 2013. Notional machines and introductory programming education. Trans. Comput. Educ. 13, 2, Article 8 (2013), 8:1-8:31 pages. https://doi.org/10. 1145/2483710.2483713
  640. Juha Sorva, Ville Karavirta, and Lauri Malmi. 2013. A review of generic program visualization systems for introductory programming education. Trans. Comput. Educ. 13, 4, Article 15 (2013), 15:1-15:64 pages. https://doi.org/10.1145/2490822
  641. Juha Sorva, Ville Karavirta, and Lauri Malmi. 2013. A review of generic program visualization systems for introductory programming education. Trans. Comput. Educ. 13, 4, Article 15 (2013), 15:1-15:64 pages. https://doi.org/10.1145/2490822
  642. Juha Sorva, Jan Lönnberg, and Lauri Malmi. 2013. Students' ways of experiencing visual program simulation. Computer Science Education 23, 3 (2013), 207-238. https://doi.org/10.1080/08993408.2013.807962
  643. Juha Sorva and Otto Seppälä. 2014. Research-based design of the first weeks of CS1. In Proceedings of the 14th Koli Calling International Conference on Computing Education Research (Koli Calling '14). ACM, New York, NY, USA, 71-80. https://doi.org/10.1145/2674683.2674690
  644. Juha Sorva and Teemu Sirkiä. 2010. UUhistle: a software tool for visual program simulation. In Proceedings of the 10th Koli Calling International Conference on Computing Education Research (Koli Calling '10). ACM, New York, NY, USA, 49-54. https://doi.org/10.1145/1930464.1930471
  645. Draylson Micael de Souza, Seiji Isotani, and Ellen Francine Barbosa. 2015. Teach- ing novice programmers using ProgTest. International Journal of Knowledge and Learning 10, 1 (2015), 60-77. https://doi.org/10.1504/IJKL.2015.071054
  646. Jaime Spacco, Paul Denny, Brad Richards, David Babcock, David Hovemeyer, James Moscola, and Robert Duvall. 2015. Analyzing student work patterns using programming exercise data. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 18-23. https://doi.org/10.1145/2676723.2677297
  647. Michael Sperber and Marcus Crestani. 2012. Form over function: teaching begin- ners how to construct programs. In Proceedings of the 2012 Annual Workshop on Scheme and Functional Programming (Scheme '12). ACM, New York, NY, USA, 81-89. https://doi.org/10.1145/2661103.2661113
  648. Andreas Stefik and Stefan Hanenberg. 2014. The programming language wars: questions and responsibilities for the programming language community. In Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software (Onward! 2014). ACM, New York, NY, USA, 283-299. https://doi.org/10.1145/2661136.2661156
  649. Andreas Stefik and Susanna Siebert. 2013. An empirical investigation into programming language syntax. Trans. Comput. Educ. 13, 4, Article 19 (2013), 19:1-19:40 pages. https://doi.org/10.1145/2534973
  650. Martijn Stegeman, Erik Barendsen, and Sjaak Smetsers. 2016. Designing a rubric for feedback on code quality in programming courses. In Proceedings of the 16th Koli Calling International Conference on Computing Education Research (Koli Calling '16). ACM, New York, NY, USA, 160-164. https://doi.org/10.1145/ 2999541.2999555
  651. Daniel E. Stevenson and Paul J. Wagner. 2006. Developing real-world pro- gramming assignments for CS1. In Proceedings of the 11th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITICSE '06). ACM, New York, NY, USA, 158-162. https://doi.org/10.1145/ 1140124.1140167
  652. Margaret-Anne Storey, Daniela Damian, Jeff Michaud, Del Myers, Marcellus Mindel, Daniel German, Mary Sanseverino, and Elizabeth Hargreaves. 2003. Improving the usability of Eclipse for novice programmers. In Proceedings of the 2003 OOPSLA Workshop on Eclipse Technology eXchange (Eclipse '03). ACM, New York, NY, USA, 35-39. https://doi.org/10.1145/965660.965668
  653. Leigh Ann Sudol-DeLyser, Mark Stehlik, and Sharon Carver. 2012. Code compre- hension problems as learning events. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 81-86. https://doi.org/10.1145/2325296. 2325319
  654. Hui Sun, Bofang Li, and Min Jiao. 2014. Yoj: an online judge system de- signed for programming courses. In 2014 9th International Conference on Computer Science & Education. IEEE, 812-816. https://doi.org/10.1109/ICCSE. 2014.6926575
  655. Kelvin Sung, Rob Nash, and Jason Pace. 2016. Building casual game SDKs for teaching CS1/2: a case study. J. Comput. Sci. Coll. 32, 1 (2016), 129-143. http://dl.acm.org/citation.cfm?id=3007225.3007253
  656. Ryo Suzuki, Gustavo Soares, Elena Glassman, Andrew Head, Loris D'Antoni, and Björn Hartmann. 2017. Exploring the design space of automatically synthesized hints for introductory programming assignments. In Proceedings of the 2017 CHI Conference Extended Abstracts on Human Factors in Computing Systems (CHI EA '17). ACM, New York, NY, USA, 2951-2958. https://doi.org/10.1145/ 3027063.3053187
  657. John Sweller. 1994. Cognitive load theory, learning difficulty, and instructional design. Learning and instruction 4, 4 (1994), 295-312.
  658. Emily S. Tabanao, Ma. Mercedes T. Rodrigo, and Matthew C. Jadud. 2011. Predict- ing at-risk novice Java programmers through the analysis of online protocols. In Proceedings of the Seventh International Workshop on Computing Education Research (ICER '11). ACM, New York, NY, USA, 85-92. https://doi.org/10.1145/ 2016911.2016930
  659. Pallavi Tadepalli and H. Conrad Cunningham. 2004. JavaCHIME: Java class hierarchy inspector and method executer. In Proceedings of the 42nd Annual Southeast Regional Conference (ACM-SE 42). ACM, New York, NY, USA, 152- 157. https://doi.org/10.1145/986537.986572
  660. Anya Tafliovich, Jennifer Campbell, and Andrew Petersen. 2013. A student per- spective on prior experience in CS1. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 239-244. https://doi.org/10.1145/2445196.2445270
  661. Yasuhiro Takemura, Hideo Nagumo, Kuo-Li Huang, and Hidekuni Tsukamoto. [n. d.]. Assessing the learners' motivation in the e-learning environ- ments for programming education. In International Conference on Web-Based Learning (ICWL '07), Howard Leung, Frederick Li, Rynson Lau, and Qing Li (Eds.). Springer, Berlin, Heidelberg, 355-366. https://doi.org/10.1007/ 978-3-540-78139-4_32
  662. Terry Tang, Scott Rixner, and Joe Warren. 2014. An environment for learning in- teractive programming. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 671- 676. https://doi.org/10.1145/2538862.2538908
  663. Donna Teague. 2009. A people-first approach to programming. In Proceedings of the Eleventh Australasian Conference on Computing Education -Volume 95 (ACE '09). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 171-180. http://dl.acm.org/citation.cfm?id=1862712.1862737
  664. Donna Teague, Malcolm Corney, Alireza Ahadi, and Raymond Lister. 2013. A qualitative think aloud study of the early neo-piagetian stages of reasoning in novice programmers. In Proceedings of the Fifteenth Australasian Computing Education Conference -Volume 136 (ACE '13). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 87-95. http://dl.acm.org/citation.cfm? id=2667199.2667209
  665. Donna Teague and Raymond Lister. 2014. Longitudinal think aloud study of a novice programmer. In Proceedings of the Sixteenth Australasian Computing Education Conference -Volume 148 (ACE '14). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 41-50. http://dl.acm.org/citation.cfm? id=2667490.2667495
  666. Donna Teague and Raymond Lister. 2014. Manifestations of preoperational reasoning on similar programming tasks. In Proceedings of the Sixteenth Australasian Computing Education Conference -Volume 148 (ACE '14). Aus- tralian Computer Society, Inc., Darlinghurst, Australia, Australia, 65-74. http: //dl.acm.org/citation.cfm?id=2667490.2667498
  667. Donna Teague and Raymond Lister. 2014. Programming: reading, writing and reversing. In Proceedings of the 2014 Conference on Innovation & Technology in Computer Science Education (ITiCSE '14). ACM, New York, NY, USA, 285- 290. https://doi.org/10.1145/2591708.2591712
  668. D. Teague and P. Roe. 2009. Learning to program : from pear-shaped to pairs. In Proceedings of the 1st International Conference on Computer Supported Education (CSEDU '09), Vol. 2. SciTePress, 151-158.
  669. Lynda Thomas, Mark Ratcliffe, and Ann Robertson. 2003. Code warriors and code-a-phobes: a study in attitude and pair programming. In Proceedings of the 34th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '03). ACM, New York, NY, USA, 363-367. https://doi.org/10.1145/ 611892.612007
  670. Errol Thompson, Andrew Luxton-Reilly, Jacqueline L. Whalley, Minjie Hu, and Phil Robbins. 2008. Bloom's taxonomy for CS assessment. In Proceedings of the Tenth Conference on Australasian Computing Education -Volume 78 (ACE '08). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 155-161. http://dl.acm.org/citation.cfm?id=1379249.1379265
  671. Neena Thota. 2014. Programming course design: phenomenographic approach to learning and teaching. In International Conference on Learning and Teaching in Computing and Engineering (LaTiCE '14). IEEE, 125-132. https://doi.org/10. 1109/LaTiCE.2014.30
  672. Veronika Thurner and Axel Böttcher. 2015. An "objects first, tests second" approach for software engineering education. In IEEE Frontiers in Education Conference (FIE '15). IEEE, 1-5. https://doi.org/10.1109/FIE.2015.7344027
  673. Nikolai Tillmann, Michal Moskal, Jonathan de Halleux, Manuel Fahndrich, Judith Bishop, Arjmand Samuel, and Tao Xie. 2012. The future of teaching program- ming is on mobile devices. In Proceedings of the 17th ACM Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE '12). ACM, New York, NY, USA, 156-161. https://doi.org/10.1145/2325296.2325336
  674. Lisa Torrey. 2011. Student interest and choice in programming assignments. J. Comput. Sci. Coll. 26, 6 (2011), 110-116. http://dl.acm.org/citation.cfm?id= 1968521.1968545
  675. Gloria Childress Townsend. 2009. Using a groupware system in CS1 to engage in- troverted students. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 16-20. https://doi.org/10.1145/1562877.1562889
  676. V Javier Traver. 2010. On compiler error messages: what they say and what they mean. Advances in Human-Computer Interaction 2010 (2010), 26. https: //doi.org/10.1155/2010/602570
  677. Nghi Truong, Peter Bancroft, and Paul Roe. 2003. A web based environment for learning to program. In Proceedings of the 26th Australasian Computer Science Conference -Volume 16 (ACSC '03). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 255-264. http://dl.acm.org/citation.cfm? id=783106.783135
  678. Hidekuni Tsukamoto, Hideo Nagumo, Yasuhiro Takemura, and Kenichi Mat- sumoto. 2009. Comparative analysis of 2D games and artwork as the motivation to learn programming. In IEEE Frontiers in Education Conference (FIE '09). IEEE, 1-6. https://doi.org/10.1109/FIE.2009.5350451
  679. Georgi Tuparov, Daniela Tuparova, and Vladimir Jordanov. 2014. Teaching sorting and searching algorithms through simulation-based learning objects in an introductory programming course. Procedia -Social and Behavioral Sciences 116 (2014), 2962-2966. https://doi.org/10.1016/j.sbspro.2014.01.688
  680. Kota Uchida and Katsuhiko Gondow. 2016. C-helper: C latent-error static/heuristic checker for novice programmers. In Proceedings of the 8th International Conference on Computer Supported Education (CSEDU '16), Vol. 1. SciTePress, 321-329.
  681. Timothy Urness. 2017. A hybrid open/closed lab for CS 1. In Proceedings of the 2017 ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '17). ACM, New York, NY, USA, 46-51. https://doi.org/10. 1145/3059009.3059014
  682. Ian Utting, Allison Elliott Tew, Mike McCracken, Lynda Thomas, Dennis Bouvier, Roger Frye, James Paterson, Michael Caspersen, Yifat Ben-David Kolikant, Juha Sorva, and Tadeusz Wilusz. 2013. A fresh look at novice programmers' perfor- mance and their teachers' expectations. In Proceedings of the ITiCSE Working Group Reports Conference on Innovation and Technology in Computer Science Education-working Group Reports (ITiCSE -WGR '13). ACM, New York, NY, USA, 15-32. https://doi.org/10.1145/2543882.2543884
  683. Evgenia Vagianou. 2006. Program working storage: a beginner's model. In Proceedings of the 6th Baltic Sea Conference on Computing Education Research (Koli Calling '06). ACM, New York, NY, USA, 69-76. https://doi.org/ 10.1145/1315803.1315816
  684. Adilson Vahldick, António José Mendes, and Maria José Marcelino. 2014. A review of games designed to improve introductory computer programming competencies. In IEEE Frontiers in Education Conference (FIE '14). IEEE, 1-7. https://doi.org/10.1109/FIE.2014.7044114
  685. David W. Valentine. 2004. CS Educational Research: A Meta-analysis of SIGCSE Technical Symposium Proceedings. In Proceedings of the 35th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '04). ACM, New York, NY, USA, 255-259. https://doi.org/10.1145/971300.971391
  686. Tammy VanDeGrift. 2015. Supporting creativity and user interaction in CS 1 homework assignments. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 54-59. https://doi.org/10.1145/2676723.2677250
  687. Elena Verdú, Luisa M Regueras, María J Verdú, José P Leal, Juan P de Castro, and Ricardo Queirós. 2012. A distributed system for learning programming on-line. Computers & Education 58, 1 (2012), 1-10. https://doi.org/10.1016/j. compedu.2011.08.015
  688. Arto Vihavainen, Jonne Airaksinen, and Christopher Watson. 2014. A systematic review of approaches for teaching introductory programming and their influence on success. In Proceedings of the Tenth Annual Conference on International Computing Education Research (ICER '14). ACM, New York, NY, USA, 19-26. https://doi.org/10.1145/2632320.2632349
  689. Arto Vihavainen, Juha Helminen, and Petri Ihantola. 2014. How novices tackle their first lines of code in an IDE: analysis of programming session traces. In Proceedings of the 14th Koli Calling International Conference on Computing Education Research (Koli Calling '14). ACM, New York, NY, USA, 109-116. https://doi.org/10.1145/2674683.2674692
  690. Arto Vihavainen, Craig S. Miller, and Amber Settle. 2015. Benefits of self- explanation in introductory programming. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 284-289. https://doi.org/10.1145/2676723.2677260
  691. Arto Vihavainen, Matti Paksula, and Matti Luukkainen. 2011. Extreme appren- ticeship method in teaching programming for beginners. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE '11). ACM, New York, NY, USA, 93-98. https://doi.org/10.1145/1953163.1953196
  692. Arto Vihavainen, Thomas Vikberg, Matti Luukkainen, and Jaakko Kurhila. 2013. Massive increase in eager TAs: experiences from extreme apprenticeship- based CS1. In Proceedings of the 18th ACM Conference on Innovation and Technology in Computer Science Education (ITiCSE '13). ACM, New York, NY, USA, 123-128. https://doi.org/10.1145/2462476.2462508
  693. Tamar Vilner, Ela Zur, and Judith Gal-Ezer. 2007. Fundamental concepts of CS1: procedural vs. object oriented paradigm -a case study. In Proceedings of the 12th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '07). ACM, New York, NY, USA, 171-175. https: //doi.org/10.1145/1268784.1268835
  694. Tamar Vilner, Ela Zur, and Ronit Sagi. 2012. Integrating video components in CS1. In Proceedings of the 43rd ACM Technical Symposium on Computer Science Education (SIGCSE '12). ACM, New York, NY, USA, 123-128. https: //doi.org/10.1145/2157136.2157176
  695. Giovanni Vincenti, James Braman, and J. Scott Hilberg. 2013. Teaching introduc- tory programming through reusable learning objects: a pilot study. J. Comput. Sci. Coll. 28, 3 (2013), 38-45. http://dl.acm.org/citation.cfm?id=2400161.2400172
  696. Milena Vujošević-Janičić, Mladen Nikolić, Dušan Tošić, and Viktor Kuncak. 2013. Software verification and graph similarity for automated evaluation of students' assignments. Information and Software Technology 55, 6 (2013), 1004-1016. https://doi.org/10.1016/j.infsof.2012.12.005
  697. Hong Wang. 2010. Teaching CS1 with Python GUI game programming. In AIP Conference Proceedings, Vol. 1247. AIP, 253-260. https://doi.org/10.1063/1. 3460234
  698. K. Wang. 2015. Enhancing the teaching of CS 1 by programming mobile apps in MIT App Inventor. In ASEE Annual Conference & Exposition (ASEE '15). 26.671.1 -26.671.9.
  699. Tiantian Wang, Xiaohong Su, Peijun Ma, Yuying Wang, and Kuanquan Wang. 2011. Ability-training-oriented automated assessment in introductory pro- gramming course. Computers & Education 56, 1 (2011), 220-226. https: //doi.org/10.1016/j.compedu.2010.08.003
  700. Kera Z. B. Watkins and Maurice J. Watkins. 2009. Towards minimizing pair incompatibilities to help retain under-represented groups in beginning pro- gramming courses using pair programming. J. Comput. Sci. Coll. 25, 2 (2009), 221-227. http://dl.acm.org/citation.cfm?id=1629036.1629071
  701. Christopher Watson and Frederick W.B. Li. 2014. Failure rates in introductory programming revisited. In Proceedings of the 2014 Conference on Innovation & Technology in Computer Science Education (ITiCSE '14). ACM, New York, NY, USA, 39-44. https://doi.org/10.1145/2591708.2591749
  702. Christopher Watson, Frederick WB Li, and Jamie L Godwin. 2013. Predicting performance in an introductory programming course by logging and analyz- ing student programming behavior. In IEEE 13th International Conference on Advanced Learning Technologies (ICALT '13). IEEE, 319-323. https://doi.org/ 10.1109/ICALT.2013.99
  703. Christopher Watson, Frederick W.B. Li, and Jamie L. Godwin. 2014. No tests required: comparing traditional and dynamic predictors of programming success. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 469-474. https://doi.org/ 10.1145/2538862.2538930
  704. Christopher Watson, Frederick W. B. Li, and Jamie L. Godwin. 2012. Blue- Fix: using crowd-sourced feedback to support programming students in er- ror diagnosis and repair. In International Conference on Web-Based Learning (ICWL '12), Elvira Popescu, Qing Li, Ralf Klamma, Howard Leung, and Marcus Specht (Eds.). Springer, Berlin, Heidelberg, 228-239. https://doi.org/10.1007/ 978-3-642-33642-3_25
  705. Christopher Watson, Frederick W. B. Li, and Rynson W. H. Lau. 2011. Learning programming languages through corrective feedback and concept visualisation. In International Conference on Web-Based Learning, Howard Leung, Elvira Popescu, Yiwei Cao, Rynson W. H. Lau, and Wolfgang Nejdl (Eds.). Springer, Berlin, Heidelberg, 11-20. https://doi.org/10.1007/978-3-642-25813-8_2
  706. Carol A Wellington, Thomas H Briggs, and C Dudley Girard. 2007. Experiences using automated 4ests and 4est driven development in computer 9cience i. In Agile 2007 (AGILE '07). IEEE, 106-112. https://doi.org/10.1109/AGILE.2007.27
  707. Briana Lowe Wellman, James Davis, and Monica Anderson. 2009. Alice and robotics in introductory CS courses. In The Fifth Richard Tapia Celebration of Diversity in Computing Conference: Intellect, Initiatives, Insight, and Innovations (TAPIA '09). ACM, New York, NY, USA, 98-102. https://doi.org/10. 1145/1565799.1565822
  708. Dinesha Weragama and Jim Reye. 2013. The PHP intelligent tutoring system. In Artificial Intelligence in Education, H. Chad Lane, Kalina Yacef, Jack Mostow, and Philip Pavlik (Eds.). Springer, Berlin, Heidelberg, 583-586. https://doi.org/ 10.1007/978-3-642-39112-5_64
  709. Lena Kallin Westin and M Nordstrom. 2004. Teaching OO concepts-a new approach. In IEEE Frontiers in Education Conference (FIE '04). IEEE, F3C-6-11. https://doi.org/10.1109/FIE.2004.1408620
  710. Jacqueline Whalley, Tony Clear, Phil Robbins, and Errol Thompson. 2011. Salient elements in novice solutions to code writing problems. In Proceedings of the Thirteenth Australasian Computing Education Conference -Volume 114 (ACE '11). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 37-46. http://dl.acm.org/citation.cfm?id=2459936.2459941
  711. Jacqueline Whalley and Nadia Kasto. 2013. Revisiting models of human con- ceptualisation in the context of a programming examination. In Proceedings of the Fifteenth Australasian Computing Education Conference -Volume 136 (ACE '13). Australian Computer Society, Inc., Darlinghurst, Australia, Australia, 67-76. http://dl.acm.org/citation.cfm?id=2667199.2667207
  712. Jacqueline Whalley and Nadia Kasto. 2014. How difficult are novice code writing tasks?: A software metrics approach. In Proceedings of the Sixteenth Australasian Computing Education Conference -Volume 148 (ACE '14). Aus- tralian Computer Society, Inc., Darlinghurst, Australia, Australia, 105-112. http://dl.acm.org/citation.cfm?id=2667490.2667503
  713. Jacqueline L. Whalley and Anne Philpott. 2011. A unit testing approach to build- ing novice programmers' skills and confidence. In Proceedings of the Thirteenth Australasian Computing Education Conference -Volume 114 (ACE '11). Aus- tralian Computer Society, Inc., Darlinghurst, Australia, Australia, 113-118. http://dl.acm.org/citation.cfm?id=2459936.2459950
  714. S. J. Whittall, W. A. C. Prashandi, G. L. S. Himasha, D. I. De Silva, and T. K. Suriyawansa. 2017. CodeMage: educational programming environment for be- ginners. In 9th International Conference on Knowledge and Smart Technology (KST '17). IEEE, 311-316. https://doi.org/10.1109/KST.2017.7886101
  715. David .M. Whittinghill, David B. Nelson, K. Andrew R. Richards, and Charles A. Calahan. 2014. Improving the affective element in introductory programming coursework for the "non programmer" student. In Proceedings of ASEE Annual Conference and Exposition. ASEE, 11.
  716. Richard Wicentowski and Tia Newhall. 2005. Using image processing projects to teach CS1 topics. In Proceedings of the 36th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '05). ACM, New York, NY, USA, 287-291. https://doi.org/10.1145/1047344.1047445
  717. E Wiebe, Laurie Williams, Julie Petlick, Nachiappan Nagappan, Suzanne Balik, Carol Miller, and Miriam Ferzli. 2003. Pair programming in introductory pro- gramming labs. In Proceedings of ASEE Annual Conference. ASEE, 3503-3514.
  718. Susan Wiedenbeck, Xiaoning Sun, and Thippaya Chintakovid. 2007. An- tecedents to end users' success in learning to program in an introduc- tory programming course. In IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC '07). IEEE, 69-72. https://doi.org/10. 1109/VLHCC.2007.8
  719. Joseph B. Wiggins, Joseph F. Grafsgaard, Kristy Elizabeth Boyer, Eric N. Wiebe, and James C. Lester. 2016. Do you think you can? the influence of student self-efficacy on the effectiveness of tutorial dialogue for computer science. International Journal of Artificial Intelligence in Education 27, 1 (2016), 130- 153. https://doi.org/10.1007/s40593-015-0091-7
  720. Chris Wilcox. 2015. The role of automation in undergraduate computer science education. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (SIGCSE '15). ACM, New York, NY, USA, 90-95. https://doi. org/10.1145/2676723.2677226
  721. Laurie Williams, Charlie McDowell, Nachiappan Nagappan, Julian Fernald, and Linda Werner. 2003. Building pair programming knowledge through a family of experiments. In Proceedings of International Symposium on Empirical Software Engineering (ISESE '03). IEEE, 143-152. https://doi.org/10.1109/ISESE. 2003.1237973
  722. Michael Wirth. 2009. Ecological footprints as case studies in programming. In IEEE Toronto International Conference Science and Technology for Humanity (TIC-STH '09). IEEE, 188-193. https://doi.org/10.1109/TIC-STH.2009.5444510
  723. Michael Wirth and Judi McCuaig. 2014. Making programs with the Raspberry PI. In Proceedings of the Western Canadian Conference on Computing Education (WCCCE '14). ACM, New York, NY, USA, Article 17, 17:1-17:5 pages. https: //doi.org/10.1145/2597959.2597970
  724. Denise Woit and David Mason. 2003. Effectiveness of online assessment. In Proceedings of the 34th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '03). ACM, New York, NY, USA, 137-141. https://doi.org/ 10.1145/611892.611952
  725. Krissi Wood, Dale Parsons, Joy Gasson, and Patricia Haden. 2013. It's never too early: pair programming in CS1. In Proceedings of the Fifteenth Australasian Computing Education Conference -Volume 136 (ACE '13). Australian Com- puter Society, Inc., Darlinghurst, Australia, Australia, 13-21. http://dl.acm.org/ citation.cfm?id=2667199.2667201
  726. Dana Wortman and Penny Rheingans. 2007. Visualizing trends in student performance across computer science courses. In Proceedings of the 38th SIGCSE Technical Symposium on Computer Science Education (SIGCSE '07).
  727. ACM, New York, NY, USA, 430-434. https://doi.org/10.1145/1227310.1227458
  728. Stelios Xinogalos, Maya Satratzemi, and Vassilios Dagdilelis. 2006. An intro- duction to object-oriented programming with a didactic microworld: objec- tKarel. Computers & Education 47, 2 (2006), 148-171. https://doi.org/10.1016/j. compedu.2004.09.005
  729. Jitendra Yasaswi, Sri Kailash, Anil Chilupuri, Suresh Purini, and C. V. Jawa- har. 2017. Unsupervised learning based approach for plagiarism detection in programming assignments. In Proceedings of the 10th Innovations in Software Engineering Conference (ISEC '17). ACM, New York, NY, USA, 117-121. https: //doi.org/10.1145/3021460.3021473
  730. Jane Yau and Mike Joy. 2007. Architecture of a context-aware and adaptive learning schedule for learning Java. In Seventh IEEE International Conference on Advanced Learning Technologies (ICALT '07). IEEE, 252-256. https://doi. org/10.1109/ICALT.2007.72
  731. Leelakrishna Yenigalla, Vinayak Sinha, Bonita Sharif, and Martha Crosby. 2016. How novices read source code in introductory courses on program- ming: an eye-tracking experiment. In Foundations of Augmented Cognition: Neuroergonomics and Operational Neuroscience, Dylan D. Schmorrow and Cali M. Fidopiastis (Eds.). Springer International Publishing, Cham, 120-131. https://doi.org/10.1007/978-3-319-39952-2_13
  732. Jooyong Yi, Umair Z. Ahmed, Amey Karkare, Shin Hwei Tan, and Abhik Roy- choudhury. 2017. A feasibility study of using automated program repair for introductory programming assignments. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE '17). ACM, New York, NY, USA, 740-751. https://doi.org/10.1145/3106237.3106262
  733. Jungsoon P Yoo, Suk Jai Seo, and Sung K Yoo. 2004. Designing an adaptive tutor for CS-I laboratory. In Proceedings of the International Conference on Internet Computing (IC'04), Vol. 1. 459-464.
  734. Nurliana Yusri, Ain Zulika, Sharifah Mashita Syed-Mohamad, and Nur'Aini Ab- dul Rashid. 2014. Tools for teaching and learning programming: a review and proposed tool. Frontiers in Artificial Intelligence and Applications 265 (2014), 859-872. https://doi.org/10.3233/978-1-61499-434-3-859
  735. Nick Z. Zacharis. 2011. Measuring the effects of virtual pair programming in an introductory programming Java course. IEEE Transactions on Education 54 (2011), 168-170. Issue 1. https://doi.org/10.1109/TE.2010.2048328
  736. Carol Zander, Lynda Thomas, Beth Simon, Laurie Murphy, Renée McCauley, Brian Hanks, and Sue Fitzgerald. 2009. Learning styles: novices decide. In Proceedings of the 14th Annual ACM SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE '09). ACM, New York, NY, USA, 223-227. https://doi.org/10.1145/1562877.1562948
  737. Matej Zapušek, Martin Možina, Ivan Bratko, Jože Rugelj, and Matej Guid. 2014. Designing an interactive teaching tool with ABML knowledge refinement loop. In Intelligent Tutoring Systems, Stefan Trausan-Matu, Kristy Elizabeth Boyer, Martha Crosby, and Kitty Panourgia (Eds.). Springer International Publishing, Cham, 575-582. https://doi.org/10.1007/978-3-319-07221-0_73
  738. Ramon Zatarain-Cabada, M. L. Barrón-Estrada, J. Moisés Osorio-Velásquez, L. Zepeda-Sánchez, and Carlos A. Reyes-García. 2008. L2Code: an author environ- ment for hybrid and personalized programming learning. In Hybrid Learning and Education, Joseph Fong, Reggie Kwan, and Fu Lee Wang (Eds.). Springer, Berlin, Heidelberg, 338-347. https://doi.org/10.1007/978-3-540-85170-7_30
  739. Daniela Zehetmeier, Anne Brüggemann-Klein, Axel Böttcher, and Veronika Thurner. 2016. A concept for interventions that address typical error classes in programming education. In IEEE Global Engineering Education Conference (EDUCON '16). IEEE, 545-554. https://doi.org/10.1109/EDUCON.2016.7474605
  740. Kurtis Zimmerman and Chandan R Rupakheti. 2015. An automated frame- work for recommending program elements to novices (n). In Proceedings of 30th IEEE/ACM International Conference on Automated Software Engineering (ASE '15). IEEE, 283-288. https://doi.org/10.1109/ASE.2015.54
  741. Daniel Zingaro. 2014. Peer instruction contributes to self-efficacy in CS1. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (SIGCSE '14). ACM, New York, NY, USA, 373-378. https://doi.org/ 10.1145/2538862.2538878
  742. Daniel Zingaro, Yuliya Cherenkova, Olessia Karpova, and Andrew Petersen. 2013. Facilitating code-writing in PI classes. In Proceeding of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE '13). ACM, New York, NY, USA, 585-590. https://doi.org/10.1145/2445196.2445369
  743. Daniel Zingaro, Andrew Petersen, and Michelle Craig. 2012. Stepping up to integrative questions on CS1 exams. In Proceedings of the 43rd ACM Technical Symposium on Computer Science Education (SIGCSE '12). ACM, New York, NY, USA, 253-258. https://doi.org/10.1145/2157136.2157215
  744. Daniel Zingaro and Leo Porter. 2016. Impact of student achievement goals on CS1 outcomes. In Proceedings of the 47th ACM Technical Symposium on Computing Science Education (SIGCSE '16). ACM, New York, NY, USA, 279- 296. https://doi.org/10.1145/2839509.2844553
  745. Imran A. Zualkernan. 2007. Using Soloman-Felder learning style index to evalu- ate pedagogical resources for introductory programming classes. In Proceedings of the 29th International Conference on Software Engineering (ICSE '07). IEEE Computer Society, Washington, DC, USA, 723-726. https://doi.org/10.1109/ ICSE.2007.96

Related papers

A Systematic Literature Review on Teaching and Learning Introductory Programming in Higher Education
HASNAH BINTI MOHAMED FP

IEEE Transactions on Education, 2018

This paper adds to the results of previous systematic literature reviews by addressing a more contemporary context of introductory programming. It proposes a categorization of introductory programming challenges, and highlights key issues for a research roadmap on introductory programming learning and teaching in higher education. Background: Despite the advances in methods and tools for teaching and learning introductory programming, dropout and failure rates are still high. Published surveys and reviews either cover papers only up to 2007, or focus on methods and tools for teaching introductory programming. Research Questions: 1) What previous skills and background knowledge are key for a novice student to learn programming? 2) What difficulties do novice students encounter in learning how to program? 3) What challenges do teachers encounter in teaching introductory programming? Methodology: Following a formal protocol, automatic and manual searches were performed for work from 2010 to 2016. Of 100 papers selected for data extraction, 89 were retained after quality assessment. Findings: The most frequently cited skills necessary for learning programming were related to problem solving and mathematical ability. Problem solving was also cited as a learning challenge, followed by motivation and engagement, and difficulties in learning the syntax of programming languages. The main teaching challenges concern the lack of appropriate methods and tools, as well as scaling and personalized teaching.

View PDFchevron_right
A survey of literature on the teaching of introductory programming
Lauri Malmi

ACM SIGCSE …, 2007

Three decades of active research on the teaching of introductory programming has had limited effect on classroom practice. Although relevant research exists across several disciplines including education and cognitive science, disciplinary differences have made this material inaccessible to many computing educators. Furthermore, computer science instructors have not had access to a comprehensive survey of research in this area. This paper collects and classifies this literature, identifies important work and mediates it to computing educators and professional bodies.

View PDFchevron_right
A review of introductory programming research 2003–2017
Brett A Becker

Proceedings of the 23rd Annual ACM Conference on Innovation and Technology in Computer Science Education, 2018

A broad review of research on the teaching and learning of programming was conducted by Robins et al. in 2003. Since this work there have been several reviews of research concerned with the teaching and learning of programming, in particular introductory programming. However, these reviews have focused on highly specific aspects, such as student misconceptions, teaching approaches, program comprehension, potentially seminal papers, research methods applied, automated feedback for exercises, competency-enhancing games, and program visualisation. While these aspects encompass a wide range of issues, they do not cover the full scope of research into novice programming. Some notable areas that have not been reviewed are assessment, academic integrity, and novice student attitudes to programming. There does not appear to have been a comprehensive review of research into introductory programming since that of Robins et al. It is therefore timely to conduct and present such a review in ord...

View PDFchevron_right
Introductory programming course: review and future implications
Uzma Omer

PeerJ Computer Science, 2021

The introductory programming course (IPC) holds a special significance in computing disciplines as this course serves as a prerequisite for studying the higher level courses. Students generally face difficulties during their initial stages of learning how to program. Continuous efforts are being made to examine this course for identifying potential improvements. This article presents the review of the state-of-the-art research exploring various components of IPC by examining sixty-six articles published between 2014 and 2020 in well-reputed research venues. The results reveal that several useful methods have been proposed to support teaching and learning in IPC. Moreover, the research in IPC presented useful ways to conduct assessments, and also demonstrated different techniques to examine improvements in the IPC contents. In addition, a variety of tools are evaluated to support the related course processes. Apart from the aforementioned facets, this research explores other interest...

View PDFchevron_right
Contemporary developments in teaching and learning introductory programming: Towards a research proposal
Christine Susan Bruce

Teaching and Learning Report, 2002

View PDFchevron_right

Related topics

  • Engineering
  • Electronic Engineering
  • Computer Science
  • Software Engineering
  • Programming Languages
  • Information Technology
  • Teaching and Learning
  • Education
  • Technology
  • Computer Engineering
  • E-learning
  • Higher Education
  • Meta-Analysis and Systematic Review
  • Software
  • Computing Education

    • Cited by

    Metodologias Ativas de Aprendizagem no Contexto de Ensino-Aprendizagem de Programação de Computadores
    João H Berssanette, Antonio Carlos de Francisco

    Educitec - Revista de Estudos e Pesquisas sobre Ensino Tecnológico

    Ao ter em vista o destaque do uso de metodologias ativas de aprendizagem e as possibilidades destas para o processo de ensino-aprendizagem de programação de computadores, bem como a ausência de estudos específicos que retratam o panorama atual de pesquisas que associam as diferentes técnicas pedagógicas de aprendizagem ativa a esse contexto, neste artigo se objetivou a identificar e caracterizar os estudos que relacionam as metodologias ativas de aprendizagem no contexto de ensino-aprendizagem de programação. Para isso, foi realizada uma revisão sistemática da literatura, entre os anos de 2014 e 2019. Por meio dessa pesquisa, selecionaram-se 38 estudos para compor a base da revisão, de forma a observar as abordagens, as técnicas pedagógicas utilizadas, a aplicação, as contribuições e as dificuldades relatadas de implementação de uso dessas metodologias no contexto já aludido.

    View PDFchevron_right
    Admitting Students through an Open Online Course in Programming
    Matti Luukkainen

    Proceedings of the 2019 ACM Conference on International Computing Education Research

    Since 2012, part of computer science student body at the University of Helsinki has been selected by using a massively open online version of the same introductory programming course that our freshmen take. In this multi-year study, we compare study success between students accepted through the online course (MOOC intake) and students accepted through the traditional entrance exam and high school matriculation exam based intake (normal intake). Our findings indicate that the MOOC intake perform better in computer science studies when looking at completed credits and grade point average, but there is no difference when considering other courses. Retention among the MOOC intake is better than among the normal intake. Additionally, students in the MOOC intake are more likely to complete their capstone project and Bachelor's thesis in the studied time-frame. However, the MOOC intake makes the already skewed gender balance more pronounced. CCS CONCEPTS • Social and professional topics → Computing education.

    View PDFchevron_right
    Dropout Time and Learners’ Performance in Computer Programming MOOCs
    Marina Lepp

    Education Sciences

    One of the problems regarding MOOCs (Massive Open Online Courses) is the high dropout rate. Although dropout periods have been studied, there is still a lack of understanding of how dropout differs for MOOCs with different levels of difficulty. A quantitative study was conducted to determine the periods with the highest dropouts in computer programming MOOCs and the performance of the dropouts on the course before dropping out. Four occurrences of three MOOCs, with different durations, difficulty of the topic, and the degree of supportive methods, were included. The results showed that dropout was highest at the beginning of all studied courses. Learners also dropped out before the project. In the easier and shorter courses, most dropouts were successful until they quit the course. In longer and more difficult courses, learners mainly dropped out in the week they started due to experiencing problems with the course activities. It is suggested to recommend that learners take courses ...

    View PDFchevron_right
    Factors Affecting the Adoption of Peer Instruction in Computing Courses
    Dennis Bouvier

    Proceedings of the Working Group Reports on Global Computing Education - CompEd-WGR '19, 2019

    The version in the Kent Academic Repository may differ from the final published version. Users are advised to check http://kar.kent.ac.uk for the status of the paper. Users should always cite the published version of record.

    View PDFchevron_right
    Theories and Models of Emotions, Attitudes, and Self-Efficacy in the Context of Programming Education
    Lauri Malmi

    Proceedings of the 2020 ACM Conference on International Computing Education Research

    Research into the relationship between learning computing and students' attitudes, beliefs, and emotions often builds on theoretical frameworks from the social sciences in order to understand how these factors influence, for example, students' motivation, study practices, and learning results. In this paper we explore the computing education research literature to identify new theoretical constructs that have emerged from this research. We focus on empirical work in programming education that extends or adapts theories or instruments from the social sciences or that independently develops theories specific to programming. From an initial data set of more than 3800 papers published in the years 2010-2019, we identify 50 papers that present a range of domain-specific theoretical constructs addressing emotions, affect, beliefs, attitudes, and self-efficacy. They include 11 validated instruments and a number of statistical models, but also grounded theories and pedagogical models. We summarize the main results of many of these constructs and provide references for all of them. We also investigate how these constructs have informed further research by analysing over 850 papers that cite these 50 papers. We categorize the ways that theories can inform further research, and give examples of papers in each of these categories. Our findings indicate that among these categories, instruments have been most widely used in further research, thus affirming their value in the field. CCS CONCEPTS • Social and professional topics → Computing education.

    View PDFchevron_right
    580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved