Skip to main content Accessibility help

We use cookies to distinguish you from other users and to provide you with a better experience on our websites. Close this message to accept cookies or find out how to manage your cookie settings.

Close cookie message
×
Hostname: page-component-8448b6f56d-mp689 Total loading time: 0 Render date: 2024-04-24T19:43:07.039Z Has data issue: false hasContentIssue false

12 - Novice Programmers and Introductory Programming

from Systemic Issues

Published online by Cambridge University Press:  15 February 2019

By
Anthony V. Robins
Edited by
Sally A. Fincher  and
Anthony V. Robins
Sally A. Fincher
Affiliation:
University of Kent, Canterbury
Anthony V. Robins
Affiliation:
University of Otago, New Zealand
Get access

Summary

One of the central topics in computing education research is the exploration of how a person learns their first programming language. This is described in terms such as understanding “novice programmers”, introductory programming, or teaching and learning in “CS1” (a first course in computer science). This chapter explores key issues and some of the important research in this domain. Topics covered include: the historical and contemporary challenges of learning to program; aptitude tests; high dropout and failure rates; "bimodal" grade distributions; programming knowledge, strategies and mental models; the properties of novice programmers; cognitive load; taxonomies and measures of programming ability; the learning edge momentum hypothesis; teaching and learning in CS1; and open questions. Although the focus is on CS1, much of this material is relevant to any context, e.g. schools. Given the increasing demand for programmers, the move of programming into school curriculums, and the well documented challenges involved, the topics of teaching and learning programming are likely to remain of significant interest in computing education for the foreseeable future.
Type
Chapter
Information
The Cambridge Handbook of Computing Education Research , pp. 327 - 376
Publisher: Cambridge University Press
Print publication year: 2019

Access options

Get access to the full version of this content by using one of the access options below. (Log in options will check for institutional or personal access. Content may require purchase if you do not have access.)

References

ACM/IEEE–CS Joint Task Force on Computing Curricula (2013). Computer Science Curricula 2013. New York: ACM Press and IEEE Computer Society Press.Google Scholar
Alaoutinen, S., & Smolander, K. (2010). Student self-assessment in a programming course using Bloom’s Revised Taxonomy. In Proceedings of the Fifteenth Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE ‘10) (pp. 155–159). New York: ACM.Google Scholar
Alexandron, G., Armoni, M., Gordon, M., & Harel, D. (2014). Scenario-based programming: Reducing the cognitive load, fostering abstract thinking. In Companion Proceedings of the 36th International Conference on Software Engineering (pp. 311–320). New York: ACM.Google Scholar
Allan, V. H., & Kolesar, M. V. (1997). Teaching computer science: A problem solving approach that works. ACM SIGCUE Outlook, 25(1–2), 2–10.Google Scholar
Altadmri, A., & Brown, N. C. (2015). 37 million compilations: Investigating novice programming mistakes in large-scale student data. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (pp. 522–527). New York: ACM.CrossRefGoogle Scholar
Anderson, L. W., Krathwohl, D. R., Airasian, P. W., Cruikshank, K. A., Mayer, R. E., Pintrich, P. R., Raths, J., & Wittrock, M. C. (Eds.) (2001). A Taxonomy for Learning and Teaching and Assessing: A Revision of Bloom’s Taxonomy of Educational Objectives. New York: Addison Wesley Longman.Google Scholar
Assessment Reform Group (1999). Assessment for Learning: Beyond the Black Box. Cambridge, UK: Cambridge University Press.Google Scholar
Barker, R. J., & Unger, E. A. (1983). A predictor for success in an introductory programming class based upon abstract reasoning development. ACM SIGCSE Bulletin, 15(1), 154–158.Google Scholar
Bateman, C. R. (1973). Predicting performance in a basic computer course. In Proceedings of the Fifth Annual Meeting of the American Institute for Decision Sciences (pp. 130–133). Atlanta, GO: AIDS Press.Google Scholar
Bau, D., Gray, J., Kelleher, C., Sheldon, J., & Turbak, F. (2017). Learnable programming: Blocks and beyond. Communications of the ACM, 60(6), 72–80.Google Scholar
Bauer, R., Mehrens, W. A., & Vinsonhaler, J. F. (1968). Predicting performance in a computer programming course. Educational and Psychological Measurement, 28, 1159–1164.Google Scholar
Beaubouef, T. B., & Mason, J. (2005). Why the high attrition rate for computer science students: Some thoughts and observations. Inroads – The SIGCSE Bulletin, 37(2), 103–106.Google Scholar
Bennedsen, J., & Caspersen, M. E. (2007). Failure rates in introductory programming. ACM SIGCSE Bulletin, 39(2), 32–36.CrossRefGoogle Scholar
Bennedsen, J., & Caspersen, M. E. (2005). An investigation of potential success factors for an introductory model-driven programming course. In Proceedings of the First International Workshop on Computing Education Research (ICER ‘05) (pp. 155–163). New York: ACM.Google Scholar
Bennedsen, J., & Caspersen, M. E. (2006). Abstraction ability as an indicator of success for learning object-oriented programming? SIGCSE Bulletin, 38(2), 39–43.Google Scholar
Bergin, S., & Reilly, R. (2006). Predicting introductory programming performance: A multi-institutional multivariate study. Computer Science Education, 16(4), 303–323.Google Scholar
Berland, M., Martin, T., Benton, T., Petrick Smith, C., & Davis, D. (2013). Using learning analytics to understand the learning pathways of novice programmers. Journal of the Learning Sciences, 22(4), 564–599.Google Scholar
Berry, M., & Kölling, M. (2014). The state of play: A notional machine for learning programming. In Proceedings of the 2014 Conference on Innovation and Technology in Computer Science Education (pp. 21–26). New York: ACM.CrossRefGoogle Scholar
Bhuiyan, S., Greer, J. E., & McCalla, G. I. (1992). Learning recursion through the use of a mental model-based programming environment. In International Conference on Intelligent Tutoring Systems (pp. 50–57). Berlin, Germany: Springer.Google Scholar
Biggs, J. B., & Collis, K. F. (1982). Evaluating the Quality of Learning: The SOLO Taxonomy (Structure of the Observed Learning Outcome). New York: Academic Press.Google Scholar
Bloom, B., Englehart, M. D., Furst, E. J., Hill, W. H., & Krathwohl, D. (1956). Taxonomy of Educational Objectives: Handbook I: Cognitive Domain. New York: Longmans.Google Scholar
Bornat, R. (2014). Camels and humps: A retraction. Retrieved from: http://eis.sla.mdx.ac.uk/staffpages/r_bornat/papers/camel_hump_retraction.pdfGoogle Scholar
Bornat, R., Dehnadi, S., & Simon, (2008). Mental models, consistency and programming aptitude. In Proceedings of the Tenth Australasian Computing Education Conference (ACE 2008) (pp. 53–62). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Boustedt, J., Eckerdal, A., McCartney, R., Moström, J. E., Ratcliffe, M., Sanders, K., & Zander, C. (2007). Threshold concepts in computer science: Do they exist and are they useful? ACM SIGCSE Bulletin, 39(1), 504–508.Google Scholar
Bower, M. (2008). A taxonomy of task types in computing. ACM SIGCSE Bulletin, 40(3), 281–285.Google Scholar
Brabrand, C., & Dahl, B. (2009). Using the SOLO taxonomy to analyze competence progression of university science curricula. Higher Education, 58(4), 531–549.Google Scholar
Brooks, F. P. (1975). The Mythical Man-Month: Essays on Software Engineering. New York: Addison-Wesley.Google Scholar
Brooks, R. E. (1977). Towards a theory of the cognitive processes in computer programming. International Journal of Man–Machine Studies, 9, 737–751.Google Scholar
Brooks, R. E. (1983). Towards a theory of the comprehension of computer programs. International Journal of Man–Machine Studies, 18, 543–554.Google Scholar
Brooks, R. E. (1990). Categories of programming knowledge and their application. International Journal of Man–Machine Studies, 33(3), 241–246.Google Scholar
Bruce, K. B. (2004). Controversy on how to teach CS 1: A discussion on the SIGCSE-members mailing list. ACM SIGCSE Bulletin, 36(4), 29–34.Google Scholar
Bruner, J. S. (1960). The Process of Education. Cambridge, MA: Harvard University Press.Google Scholar
Buck, D., & Stucki, D. J. (2000). Design early considered harmful: Graduated exposure to complexity and structure based on levels of cognitive development. ACM SIGCSE Bulletin, 32(1), 75–79.Google Scholar
Burkhardt, J. M., Détienne, F., & Wiedenbeck, S. (2002). Object-oriented program comprehension: Effect of expertise, task and phase. Empirical Software Engineering, 7(2), 115–156.Google Scholar
Burkhardt, J. M., Détienne, F., & Wiedenbeck, S. (1997). Mental representations constructed by experts and novices in object-oriented program comprehension. In Proceedings of the IFIP TC13 International Conference on Human–Computer Interaction (INTERACT ‘97) (pp. 339–346). London, UK: Chapman & Hall.Google Scholar
Busjahn, T., & Schulte, C. (2013). The use of code reading in teaching programming. In Proceedings of the 13th Koli Calling International Conference on Computing Education Research (pp. 3–11). New York: ACM.Google Scholar
Cañas, J. J., Bajo, M. T., & Gonzalvo, P. (1994). Mental models and computer programming. International Journal of Human–Computer Studies, 40(5), 795–811.CrossRefGoogle Scholar
Carter, A. S., Hundhausen, C. D., & Adesope, O. (2017). Blending measures of programming and social behavior into predictive models of student achievement in early computing courses. ACM Transactions on Computing Education (TOCE), 17(3), 12.Google Scholar
Caspersen, M. E., & Bennedsen, J. (2007). Instructional design of a programming course: a learning theoretic approach. In Proceedings of the Third International Workshop on Computing Education Research (pp. 111–122). New York: ACM.CrossRefGoogle Scholar
Caspersen, M. E., Larsen, K. D., & Bennedsen, J. (2007). Mental models and programming aptitude. ACM SIGCSE Bulletin, 39(3), 206–210.Google Scholar
Castro, F. E. V., & Fisler, K. (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) (pp. 10–19). New York: ACM.Google Scholar
Clancy, M. J., & Linn, M. C. (1999). Patterns and pedagogy. ACM SIGCSE Bulletin, 31(1), 37–42.Google Scholar
Clear, T., Whalley, J., Lister, R. F., Carbone, A., Hu, M., Sheard, J., Simon, B., & Thompson, E. (2008). Reliably classifying novice programmer exam responses using the SOLO taxonomy. In 21st Annual Conference of the National Advisory Committee on Computing Qualifications (NACCQ 2008) (pp. 23–30). Auckland, New Zealand: National Advisory Committee on Computing Qualifications.Google Scholar
Corney, M., Teague, D., & Thomas, R. N. (2010). Engaging students in programming. In Proceedings of the Twelfth Australasian Conference on Computing Education Volume 103 (pp. 63–72). Darlinghurst, Australia: Australian Computer Society,Google Scholar
Corney, M., Teague, D., Ahadi, A., & Lister, R. (2012). Some empirical results for neo-Piagetian reasoning in novice programmers and the relationship to code explanation questions. In Proceedings of the Fourteenth Australasian Computing Education Conference Volume 123 (pp. 77–86). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Corritore, C. L., & Wiedenbeck, S. (1991). What do novices learn during program comprehension? International Journal of Human–Computer Interaction, 3, 199–222.Google Scholar
Cowan, N. (2001). The magical number 4 in short-term memory: A reconsideration of mental storage capacity. Behavioral and Brain Sciences, 24, 87–185.Google Scholar
Cronan, T. P., Embry, P. R., & White, S. D. (1989). Identifying factors that influence performance of non-computing majors in the business computer information systems course. Journal of Research on Computing in Education, 21 (4), 431–441.Google Scholar
CSTA (2017). About the CSTA K–12 Computer Science Standards. Retrieved from www.csteachers.org/page/standardsGoogle Scholar
Curtis, B. (1984). Fifteen years of psychology in software engineering: Individual differences and cognitive science. In Proceedings of the 7th International Conference on Software Engineering (pp. 97–106). New York: IEEE.Google Scholar
Dauw, D. (1967). Vocational interests of highly creative computer personnel. Personnel Journal, 46(10), 653–659.Google Scholar
Davies, S. P. (1993). Models and theories of programming strategy. International Journal of Man–Machine Studies, 39, 237–267.CrossRefGoogle Scholar
Davies, S. P. (2008). The effects of emphasizing computational thinking in an introductory programming course. In Frontiers in Education Conference (FIE 2008) (p. T2C-3). New York: IEEE.Google Scholar
Dehnadi, S. (2006). Abstract for Dehnadi & Bornat (2006). Retrieved from www.eis.mdx.ac.uk/research/PhDArea/saeedGoogle Scholar
Dehnadi, S., & Bornat, R. (2006). The camel has two humps (working title). Retrieved from www.eis.mdx.ac.uk/research/PhDArea/saeed/paper1.pdfGoogle Scholar
Dijkstra, E. W. (1989). On the cruelty of really teaching computer science. Communications of the ACM, 32(12), 1398–1404.Google Scholar
du Boulay, B., O’Shea, T., & Monk, J. (1989). The black box inside the glass box: Presenting computing concepts to novices. In Soloway, E. & Spohrer, J. C. (Eds.), Studying the Novice Programmer (pp. 431–446). Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
du Boulay, B. (1986). Some difficulties of learning to program. Journal of Educational Computing Research, 2(1), 57–73.Google Scholar
du Boulay, B. (1989). Some difficulties of learning to program. In Soloway, E. & Spohrer, J. C. (Eds.), Studying the Novice Programmer (pp. 283–299). Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
Ebrahimi, A. (1994). Novice programmer errors: Language constructs and plan composition. International Journal of Human–Computer Studies, 41(4), 457–480.Google Scholar
Eckerdal, A. (2009). Novice Programming Students’ Learning of Concepts and Practice (doctoral dissertation). Acta Universitatis Upsaliensis.Google Scholar
Eckerdal, A., Thuné, M., & Berglund, A. (2005). What does it take to learn “programming thinking”? In Proceedings of the First International Workshop on Computing Education Research (pp. 135–142). New York: ACM.Google Scholar
Elarde, J. (2016). Toward improving introductory programming student course success rates: experiences with a modified cohort model to student success sessions. Journal of Computing Sciences in Colleges, 32(2), 113–119.Google Scholar
Ensmenger, N. L. (2010). The Computer Boys Take Over: Computers, Programmers, and the Politics of Technical Expertise. Cambridge, MA: MIT Press.Google Scholar
Evans, G. E., & Simkin, M. G. (1989). What best predicts computer proficiency? Communications of the ACM, 32(11), 1322–1327.Google Scholar
Falkner, K., Vivian, R., & Falkner, N. J. (2013). Neo-Piagetian forms of reasoning in software development process construction. In Learning and Teaching in Computing and Engineering (LaTiCE) (pp. 31–38). New York: IEEE.Google Scholar
Feldman, D. H. (2004). Piaget’s stages: The unfinished symphony of cognitive development. New Ideas in Psychology, 22, 175–231.Google Scholar
Felleisen, M., Findler, R. B., Flatt, M., & Krishnamurthi, S. (2001). How to Design Programs: An Introduction to Programming and Computing. Cambridge, MA: MIT Press.Google Scholar
Fincher, S. (1999). What are we doing when we teach programming? In Frontiers in Education Conference (FIE’99) Volume 1 (pp. 12A4-1–12A4-5). New York: IEEE.Google Scholar
Findler, R. B., Clements, J., Flanagan, C., Flatt, M., Krishnamurthi, S., Steckler, P., & Felleisen, M. (2002). DrScheme: A programming environment for Scheme. Journal of Functional Programming, 12(2), 159–182.Google Scholar
Fisler, K. (2014). The recurring Rainfall Problem. In Proceedings of the Tenth Annual Conference on International Computing Education Research (pp. 35–42). New York: ACM.Google Scholar
Freeman, E., Robson, E., Bates, B., & Sierra, K. (2004). Head First Design Patterns: A Brain-Friendly Guide. Sebastopol, CA: O’Reilly Media.Google Scholar
Fuller, U., Johnson, C. G., Ahoniemi, T., Cukierman, D., Hernán-Losada, I., Jackova, , Lahtinen, J., Lewis, E., Thompson, T. L., Riedesel, D. M., , C., & Thompson, E. (2007). Developing a computer science-specific learning taxonomy. ACM SIGCSE Bulletin, 39(4), 152–170.Google Scholar
Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1995). Design Patterns: Elements of Reusable Object-Oriented Software. New York: Addison-Wesley.Google Scholar
Garcia, R. A. (1987). Identifying the Academic Factors that Predict the Success of Entering Freshmen in a Beginning Computer Science Course (doctoral dissertation). Texas Tech University.Google Scholar
Garner, S. (2002). Reducing the cognitive load on novice programmers. In Proceedings of World Conference on Educational Multimedia, Hypermedia and Telecommunications (pp. 578–583). Chesapeake, VA: AACE.Google Scholar
Garner, S., Haden, P., & Robins, A. (2005). My program is correct but it doesn’t run: A preliminary investigation of novice programmers’ problems. In Proceedings of the Seventh Australasian Computing Education Conference (ACE2005) CRPIT 42 (pp. 173–180). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Gentner, D. (2002). Mental models, psychology of. In Smelser, N. & Bates, P. B. (Eds.), International Encyclopedia of the Social and Behavioral Sciences (pp. 9683–9687). Amsterdam, The Netherlands: Elsevier Science.Google Scholar
Gentner, D., & Stevens, A. L. (Eds.) (1983). Mental Models. Hillsdale, NJ: Erlbaum.Google Scholar
Gibbs, W. W. (1994). Software’s chronic crisis. Scientific American, 271(3), 86–95.Google Scholar
Ginat, D., & Menashe, E. (2015). SOLO taxonomy for assessing novices’ algorithmic design. In Proceedings of the 46th ACM Technical Symposium on Computer Science Education (pp. 452–457). New York: ACM.Google Scholar
Gluga, R., Kay, J., Lister, R., Kleitman, S., & Lever, T. (2012). Coming to terms with Bloom: an online tutorial for teachers of programming fundamentals. In Proceedings of the Fourteenth Australasian Computing Education Conference Volume 123 (pp. 147–156). Darlinghurst, Australia: Australian Computer Society,Google Scholar
Gray, W. D., & Anderson, J. R. (1987). Change-episodes in coding: When and how do programmers change their code? In Olson, G. M., Sheppard, S., & Soloway, E. (Eds.), Empirical Studies of Programmers: Second Workshop (pp. 185–197). Norwood, NJ: Ablex.Google Scholar
Gray, S., St Clair, C., James, R., & Mead, J. (2007). Suggestions for graduated exposure to programming concepts using fading worked examples. In Proceedings of the Third International Workshop on Computing Education Research (pp. 99–110). New York: ACM.CrossRefGoogle Scholar
Green, T. R. G. (1990). Programming languages as information structures. In Hoc, J. M., Green, T. R. G., Samurçay, R., & Gillmore, D. J. (Eds.), Psychology of Programming (pp. 117–137). London, UK: Academic Press.Google Scholar
Guzdial, M. (2007) What makes programming so hard? Retrieved from http://home.cc.gatech.edu/csl/uploads/6/Guzdial-blog-pieces-on-what-is-CSEd.pdfGoogle Scholar
Guzdial, M. (2010). Why is it so hard to learn to program? In Oram, A. & Wilson, G. (Eds.), Making Software: What Really Works, and Why We Believe It (pp. 111–124). Sebastopol, CA: O’Reilly Media.Google Scholar
Guzdial, M., & Soloway, E. (2002). Teaching the Nintendo generation to program. Communications of the ACM, 45(4), 17–21.Google Scholar
Hattie, J. A. (2009). Visible Learning: A Synthesis of 800+ Meta-Analyses on Achievement. Abingdon, UK: Routledge.Google Scholar
Hattie, J. (2012). Visible Learning for Teachers: Maximizing Impact on Learning. Abingdon, UK: Routledge.Google Scholar
Hiebert, J., & Lefevre, P. (1986). Conceptual and procedural knowledge in mathematics: An introductory analysis. In Hiebert, J. (Ed.), Conceptual and Procedural Knowledge: The Case of Mathematics, 2 (pp. 1–27). Hillsdale, NJ: Erlbaum.Google Scholar
Hill, G. J. (2016). Review of a problems-first approach to first year undergraduate programming. In Kassel, S. & Wu, B. (Eds.), Software Engineering Education Going Agile (pp. 73–80). Basel, Switzerland: Springer International Publishing.Google Scholar
Hoc, J. M., & Nguyen-Xuan, A. (1990). Language semantics, mental models and analogy. In Hoc, J. M., Green, T. R. G., Samurçay, R., & Gillmore, D. J. (Eds.), Psychology of Programming (pp. 139–156). London, UK: Academic Press.Google Scholar
Hoda, R., & Andreae, P. (2014). It’s not them, it’s us! Why computer science fails to impress many first years. In Proceedings of the Sixteenth Australasian Computing Education Conference Volume 148 (pp. 159–162). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Höök, L. J., & Eckerdal, A. (2015). On the bimodality in an introductory programming course: An analysis of student performance factors. In Learning and Teaching in Computing and Engineering (LaTiCE 2015) (pp. 79–86). New York: IEEE.Google Scholar
Howles, T. (2009). A study of attrition and the use of student learning communities in the computer science introductory programming sequence. Computer Science Education, 19(1), 1–13.Google Scholar
Hudak, M. A., & Anderson, D. E. (1990). Formal operations and learning style predict success in statistics and computer science courses. Teaching of Psychology, 17(4), 231–234.Google Scholar
Hundley, J. (2008). A review of using design patterns in CS1. In Proceedings of the 46th Annual Southeast Regional Conference (ACM SE’08) (pp. 30–33). New York: ACM.Google Scholar
Izu, C., Weerasinghe, A., & Pope, C. (2016). A study of code design skills in novice programmers using the SOLO taxonomy. In Proceedings of the 2016 ACM Conference on International Computing Education Research (pp. 251–259). New York: ACM.Google Scholar
Jadud, M. C. (2006). Methods and tools for exploring novice compilation behaviour. In Proceedings of the Second International Workshop on Computing Education Research (pp. 73–84). New York: ACM.Google Scholar
Jimoyiannis, A. (2013). Using SOLO taxonomy to explore students’ mental models of the programming variable and the assignment statement. Themes in Science and Technology Education, 4(2), 53–74.Google Scholar
Johnson-Laird, P. N. (1983). Mental Models: Towards a Cognitive Science of Language, Inference, and Consciousness. Cambridge, MA: Harvard University Press.Google Scholar
Johnson, C. G., & Fuller, U. (2006). Is Bloom’s taxonomy appropriate for computer science? In Proceedings of the 6th Baltic Sea Conference on Computing Education Research, Koli Calling (pp. 120–123). New York: ACM.Google Scholar
Kay, J., Barg, M., Fekete, A., Greening, T., Hollands, O., Kingston, J., & Crawford, K. (2000). Problem-based learning for foundation computer science courses. Computer Science Education, 10, 109–128.Google Scholar
Kelleher, C., & Pausch, R. (2005). Lowering the barriers to programming: A taxonomy of programming environments and languages for novice programmers. ACM Computing Surveys (CSUR), 37(2), 83–137.Google Scholar
Kim, J., & Lerch, F. J. (1997). Why is programming (sometimes) so difficult? Programming as scientific discovery in multiple problem spaces. Information Systems Research, 8(1), 25–50.Google Scholar
Kinnunen, P., & Malmi, L. (2006). Why students drop out CS1 course? In Proceedings of the Second International Workshop on Computing Education Research (pp. 97–108). New York: ACM.CrossRefGoogle Scholar
Kölling, M. (2009). Quality-oriented teaching of programming. Retrieved from: https://blogs.kcl.ac.uk/proged/2009/09/04/quality-oriented-teaching-of-programmingGoogle Scholar
Kölling, M. (2010). The Greenfoot programming environment. ACM Transactions on Computing Education (TOCE), 10(4), 14.Google Scholar
Kölling, M., Quig, , Patterson, B., , A., & Rosenberg, J. (2003). The BlueJ system and its pedagogy. Computer Science Education, 13(4), 249–268.Google Scholar
Koulouri, T., Lauria, S., & Macredie, R. D. (2014). Teaching introductory programming: A quantitative evaluation of different approaches. ACM Transactions on Computing Education (TOCE), 14(4), 26.Google Scholar
Krathwohl, D. R. (2002). A revision of Bloom’s taxonomy: An overview. Theory Into Practice, 41(4), 212–218.Google Scholar
Kunkle, W. M., & Allen, R. B. (2016). The impact of different teaching approaches and languages on student learning of introductory programming concepts. ACM Transactions on Computing Education (TOCE), 16(1), 3.Google Scholar
Kurland, D. M., Pea, R. D., Clement, C., & Mawby, R. (1989). A study of the development of programming ability and thinking skills in high school students. In Soloway, E. & Spohrer, J. C. (Eds.), Studying the Novice Programmer (pp. 83–112). Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
Kurland, D. M., & Pea, R. D. (1985). Children’s mental models of recursive LOGO programs. Journal of Educational Computing Research, 1(2), 235–243.Google Scholar
Lahtinen, E., Ala-Mutka, K. & Järvinen, H. M. (2005). A study of the difficulties of novice programmers. ACM SIGCSE Bulletin, 37(3), 14–18.Google Scholar
Lau, W. W., & Yuen, A. H. (2011). Modelling programming performance: Beyond the influence of learner characteristics. Computers & Education, 57(1), 1202–1213.Google Scholar
Lawson, C. (1962). A survey of computer facility management. Datamation, 8(7), 29–32.Google Scholar
Lewis, T. L., Rosson, M. B., & Pérez-Quiñones, M. A. (2004). What do the experts say?: Teaching introductory design from an expert’s perspective. ACM SIGCSE Bulletin, 36(1), 296–300.Google Scholar
Linn, M. C., & Dalbey, J. (1989). Cognitive consequences of programming instruction. In Soloway, E. & Spohrer, J. C. (Eds.), Studying the Novice Programmer (pp. 57–81). Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
Linn, M. C., & Clancy, M. J. (1992). The case for case studies of programming problems. Communications of the ACM, 35(3), 121–132.Google Scholar
Lister, R. (2000). On blooming first year programming, and its blooming assessment. In Proceedings of the Australasian Conference on Computing Education (ACSE ‘00) (pp. 158–162). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Lister, R. (2010). Geek genes and bimodal grades. ACM Inroads, 1(3), 16–17.Google Scholar
Lister, R. (2011). Concrete and other neo-Piagetian forms of reasoning in the novice programmer. In Proceedings of the Thirteenth Australasian Computing Education Conference Volume 114 (pp. 9–18). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Lister, R., & Leaney, J. (2003a). Introductory programming, criterion-referencing, and Bloom. ACM SIGCSE Bulletin, 35(1), 143–147.Google Scholar
Lister, R., & Leaney, J. (2003b). First year programming: Let all the flowers bloom. In Proceedings of the Fifth Australasian Computing Education Conference (ACE 2003) Volume 20 (pp. 221–230). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Lister, R., Adams, E. S., Fitzgerald, S., Fone, W., Hamer, J., Lindholm, M., McCartney, R., Moström, J. E., Sanders, K., Seppälä, O., & Simon, B. (2004). A multi-national study of reading and tracing skills in novice programmers. ACM SIGCSE Bulletin, 36(4), 119–150.Google Scholar
Lister, R., Clear, T., Bouvier, D. J., Carter, P., Eckerdal, A., Jacková, J., Lopez, , McCartney, M., Robbins, R., Seppälä, P., O., & Thompson, E. (2010). Naturally occurring data as research instrument: Analyzing examination responses to study the novice programmer. ACM SIGCSE Bulletin, 41(4), 156–173.Google Scholar
Lister, R., Simon, B., Thompson, E., Whalley, J. L., & Prasad, C. (2006). Not seeing the forest for the trees: Novice programmers and the SOLO taxonomy. ACM SIGCSE Bulletin, 38(3), 118–122.Google Scholar
Lopez, M., Whalley, J., Robbins, P., & Lister, R. (2008). Relationships between reading, tracing and writing skills in introductory programming. In Proceedings of the Fourth International Workshop on Computing Education Research (pp. 101–112). New York: ACM.Google Scholar
Luxton-Reilly, A. (2016). Learning to program is easy. In Proceedings of the 2016 ACM Conference on Innovation and Technology in Computer Science Education (pp. 284–289). New York: ACM.CrossRefGoogle Scholar
Ma, L., Ferguson, J., Roper, M., & Wood, M. (2007). Investigating the viability of mental models held by novice programmers. ACM SIGCSE Bulletin, 39(1), 499–503.Google Scholar
Maloney, J., Resnick, M., Rusk, N., Silverman, B., & Eastmond, E. (2010). The scratch programming language and environment. ACM Transactions on Computing Education (TOCE), 10(4), 16.Google Scholar
Mannila, L., Peltomäki, M., & Salakoski, T. (2006). What about a simple language? Analyzing the difficulties in learning to program. Computer Science Education, 16(3), 211–227.Google Scholar
Margulieux, L. E., Catrambone, R., & Schaeffer, L. M. (2018). Varying effects of subgoal labeled expository text in programming, chemistry, and statistics. Instructional Science, 46(5), 707–722.Google Scholar
Mason, R., & Cooper, G. (2013). Distractions in programming environments. In Proceedings of the Fifteenth Australasian Computing Education Conference Volume 136 (pp. 23–30). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Mayer, R. E. (1989). The psychology of how novices learn computer programming. In Soloway, E. & Spohrer, J. C. (Eds.), Studying the Novice Programmer (pp. 129–159). Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
Mayer, D. B., & Stalnaker, A. W. (1968). Selection and evaluation of computer personnel – The research history of SIG/CPR. In The Proceedings of the 1968 ACM National Conference (23rd ACM National Conference) (pp. 657–670). New York: ACM.Google Scholar
Mayer, R. E. (1985). Learning in complex domains: A cognitive analysis of computer programming. Psychology of Learning and Motivation, 19, 89–130.Google Scholar
Mayer, R. E. (1992). Teaching for transfer of problem-solving skills to computer programming. In De Corte, E., Linn, M. C., Mandl, H., & Verschaffel, L. (Eds.), Computer-Based Learning Environments and Problem Solving. NATO ASI Series (Series F: Computer and Systems Sciences), Vol. 84 (pp. 193–206). Berlin, Germany: Springer.Google Scholar
McCall, D., & Kölling, M. (2014). Meaningful categorisation of novice programmer errors. In Frontiers in Education Conference (FIE) (pp. 1–8). New York: IEEE.Google Scholar
McCane, B., Ott, C., Meek, N., & Robins, A. (2017). Mastery learning in introductory programming. In Proceedings of the Nineteenth Australasian Computing Education Conference (pp. 1–10). New York: ACM.Google Scholar
McCracken, M., Almstrum, V., Diaz, D., Guzdial, M., Hagan, D., Kolikant, Y. B., Laxer, C., Thomas, L., Utting, I., & Wilusz, T. (2001). A multi-national, multi-institutional study of assessment of programming skills of first-year CS students. ACM SIGCSE Bulletin, 33, 125–180.Google Scholar
McNamara, W. J. (1967). The selection of computer personnel: Past, present, future. In Proceedings of the Fifth SIGCPR Conference on Computer Personnel Research (SIGCPR ‘67) (pp. 52–56). New York: ACM Press.Google Scholar
Mead, J., Gray, S., Hamer, J., James, R., Sorva, J., Clair, C. S., & Thomas, L. (2006). A cognitive approach to identifying measurable milestones for programming skill acquisition. ACM SIGCSE Bulletin, 38(4), 182–194.Google Scholar
Meerbaum-Salant, O., Armoni, M., & Ben-Ari, M. (2010). Learning computer science concepts with Scratch. In Proceedings of the Sixth International Workshop on Computing Education Research (ICER ‘10) (pp. 69–76). New York: ACM.Google Scholar
Mendes, A. J., Paquete, L., Cardoso, A., & Gomes, A. (2012). Increasing student commitment in introductory programming learning. In Frontiers in Education Conference (FIE) (pp. 1–6). New York: IEEE.Google Scholar
Meyer, J. H., & Land, R. (Eds.) (2006). Overcoming Barriers to Student Understanding: Threshold Concepts and Troublesome Knowledge. London, UK: Routledge.Google Scholar
Meyer, J. H. F., & Land, R. (2003). Threshold Concepts and Troublesome Knowledge: Linkages to Ways of Thinking and Practising within the Disciplines (ETL Project: Occasional Report No. 4). Edinburgh, UK: University of Edinburgh Press.Google Scholar
Mitchell, M. L., & Jolley, J. M. (2012). Research Design Explained, 8th edn. Wadsworth, CA: Cengage Learning.Google Scholar
Morra, S., Gobbo, C., Marini, Z., & Sheese, R. (2007). Cognitive Development: Neo-Piagetian Perspectives. New York: Psychology Press.Google Scholar
Morrison, B. B., Dorn, B., & Guzdial, M. (2014). Measuring cognitive load in introductory CS: Adaptation of an instrument. In Proceedings of the Tenth Annual Conference on International Computing Education Research (pp. 131–138). New York: ACM.Google Scholar
Newman, R., Gatward, R., & Poppleton, M. (1970). Paradigms for teaching computer programming in higher education. WIT Transactions on Information and Communication Technologies, 7, 299–305.Google Scholar
Newstead, P. R. (1975). Grade and ability predictions in an introductory programming course. ACM SIGCSE Bulletin, 7, 87–91.Google Scholar
O’Donnell, R. (2009). Threshold concepts and their relevance to economics. In 14th Annual Australasian Teaching Economics Conference (ATEC 2009) (pp. 190–200). Brisbane, Australia: School of Economics and Finance, Queensland University of Technology.Google Scholar
Oliver, D., Dobele, T., Greber, M., & Roberts, T. (2004). This course has a Bloom rating of 3.9. In Proceedings of the Sixth Australasian Conference on Computing Education (ACE ‘04) (pp. 227–231). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Ormerod, T. (1990). Human cognition and programming. In Hoc, J. M., Green, T. R. G., Samurçay, R., & Gillmore, D. J. (Eds.), Psychology of Programming (pp. 63–82). London, UK: Academic Press.Google Scholar
Paas, F., Renkl, A., & Sweller, J. (2003). Cognitive load theory and instructional design: Recent developments. Educational Psychologist, 38(1), 1–4.Google Scholar
Palumbo, D. (1990). Programming language/problem-solving research: A review of relevant issues. Review of Educational Research, 60(1), 65–89.Google Scholar
Parsons, D., & Haden, P. (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 (ACE ‘06) Volume 52 (pp. 157–163). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Patitsas, E., Berlin, J., Craig, M., & Easterbrook, S. (2016). Evidence that computer science grades are not bimodal. In Proceedings of the 2016 ACM Conference on International Computing Education Research (pp. 113–121). New York: ACM.Google Scholar
Pea, R. D. (1986). Language-independent conceptual “bugs” in novice programming. Journal of Educational Computing Research, 2(1), 25–36.Google Scholar
Pea, R. D., & Kurland, D. M. (1984). On the Cognitive Prerequisites of Learning Computer Programming. Technical Report No. 18. New York: Bank Street College of Education.Google Scholar
Pears, A., Seidman, S., Malmi, L., Mannila, L., Adams, E., Bennedsen, J., Devlin, M., & Paterson, J. (2007). A survey of literature on the teaching of introductory programming. ACM SIGCSE Bulletin, 39(4), 204–223.Google Scholar
Perkins, D. N., & Martin, F (1986). Fragile knowledge and neglected strategies in novice programmers. In Soloway, E. & Iyengar, S. (Eds.), Empirical Studies of Programmers, First Workshop (pp. 213–229). Norwood, NJ: Ablex.Google Scholar
Perkins, D. N., Hancock, C., Hobbs, R., Martin, F., & Simmons, R. (1989). Conditions of learning in novice programmers. In Soloway, E. & Spohrer, J. C. (Eds.), Studying the Novice Programmer (pp. 261–279). Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
Piaget, J. (1964). Part I: Cognitive development in children: Piaget development and learning. Journal of Research in Science Teaching, 2(3), 176–186.Google Scholar
Piaget, J. (1971a). The theory of stages in cognitive development. In Green, D. R., Ford, M. P., & Flamer, G. B. (Eds.), Measurement and Piaget (pp. 1–11). New York: McGraw-Hill.Google Scholar
Piaget, J. (1971b). Developmental stages and developmental processes. In Green, D. R., Ford, M. P., & Flamer, G. B. (Eds.), Measurement and Piaget (pp. 172–188). New York: McGraw-Hill.Google Scholar
Plass, J. L., Moreno, R., & Brünken, R. (Eds.) (2010). Cognitive Load Theory. Cambridge, UK: Cambridge University Press.Google Scholar
Porter, L., & Zingaro, D. (2014). Importance of early performance in CS1: Two conflicting assessment stories. In Proceedings of the 45th ACM Technical Symposium on Computer Science Education (pp. 295–300). New York: ACM.Google Scholar
Porter, L., Zingaro, D., & Lister, R. (2014). Predicting student success using fine grain clicker data. In Proceedings of the Tenth Annual Conference on International Computing Education Research (pp. 51–58). New York: ACM.Google Scholar
Price, T. W., & Barnes, T. (2015). Comparing textual and block interfaces in a novice programming environment. In Proceedings of the Eleventh Annual International Conference on International Computing Education Research (pp. 91–99). New York: ACM.Google Scholar
Rist, R. S. (1995). Program structure and design. Cognitive Science, 19, 507–562.Google Scholar
Rist, R. S. (1986). Plans in programming: Definition, demonstration, and development. In Soloway, E. & Iyengar, S. (Eds.), Empirical Studies of Programmers (pp. 28–47). Norwood, NJ: Ablex Publishing.Google Scholar
Rist, R. S. (1989). Schema creation in programming. Cognitive Science, 13, 389–414.Google Scholar
Rist, R. S. (2004). Learning to program: Schema creation, application, and evaluation. In Fincher, S. & Petre, M. (Eds.), Computer Science Education Research (pp. 175–195). London, UK: Taylor & Francis.Google Scholar
Robins, A. V. (2010). Learning edge momentum: A new account of outcomes in CS1. Computer Science Education, 20, 37–71.Google Scholar
Robins, A. V. (2018). Outcomes in introductory programming. Computer Science Technical Report, OUCS-2018-02, The University of Otago. Retrieved from www.otago.ac.nz/computer-science/otago685184.pdfGoogle Scholar
Robins, A. V., Haden, P., & Garner, S. (2006). Problem distributions in a CS1 course. In Proceedings of the Eighth Australasian Computing Education Conference (ACE2006), CRPIT, 52 (pp. 165–173). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Robins, A. V., Rountree, J., & Rountree, N. (2003). Learning and teaching programming: A review and discussion. Computer Science Education, 13(2), 137–172.Google Scholar
Rogalski, J., & Samurçay, R. (1990). Acquisition of programming knowledge and skills. In Hoc, J. M., Green, T. R. G., Samurçay, R., & Gillmore, D. J. (Eds.), Psychology of Programming (pp. 157–174). London, UK: Academic Press.Google Scholar
Rountree, J., Robins, A., & Rountree, N. (2013). Elaborating on threshold concepts, Computer Science Education, 23(3), 265–289.Google Scholar
Rountree, N., Rountree, J., Robins, A., & Hannah, R. (2004). Interacting factors that predict success and failure in a CS1 course. ACM SIGCSE Bulletin, 36(4), 101–104.Google Scholar
Rowbottom, D. P. (2007). Demystifying threshold concepts. Journal of Philosophy of Education, 41, 263–270.Google Scholar
Sackman, H., Erickson, W. J., & Grant, E. E. (1968). Exploratory experimental studies comparing online and offline programming performance. Communications of the ACM, 11(1), 3–11.Google Scholar
Sarawagi, N. (2014). A flipped CS0 classroom: Applying Bloom’s taxonomy to algorithmic thinking. Journal of Computing Sciences in Colleges, 29(6), 21–28.Google Scholar
Schneider, G. M. (1978). The introductory programming course in computer science: Ten principles. ACM SIGCSE Bulletin, 10(1), 107–114.Google Scholar
Schulte, C., & Bennedsen, J. (2006). What do teachers teach in introductory programming? In Proceedings of the Second International Workshop on Computing Education Research (pp. 17–28). New York: ACM.Google Scholar
Schwill, A. (1997). Computer science education based on fundamental ideas. In Passey, D. & Samways, B. (Eds.), Information Technology. IFIP Advances in Information and Communication Technology (pp. 285–291). Boston, MA: Springer.Google Scholar
Schwill, A. (1994). Fundamental ideas of computer science. EATCS-Bulletin, 53, 274–295.Google Scholar
Scott, T. (2003). Bloom’s Taxonomy applied to testing in computer science classes. Journal of Computing in Small Colleges, 19(1), 267–274.Google Scholar
Sheard, J., & Hagan, D. (1998). Our failing students: A study of a repeat group. ACM SIGCSE Bulletin, 30(3), 223–227.Google Scholar
Sheard, J., Carbone, A., Lister, R., Simon, B., Thompson, E., & Whalley, J. L. (2008). Going SOLO to assess novice programmers. ACM SIGCSE Bulletin, 40(3), 209–213.Google Scholar
Sheil, B. A. (1981). The psychological study of programming. Computing Surveys, 13, 101–120.Google Scholar
Shih, Y. F., & Alessi, S. M. (1993). Mental models and transfer of learning in computer programming. Journal of Research on Computing in Education, 26(2), 154–175.Google Scholar
Shinners-Kennedy, D., & Fincher, S. A. (2013). Identifying threshold concepts: From dead end to a new direction. In Proceedings of the Ninth Annual International ACM Conference on International Computing Education Research (pp. 9–18). New York: ACM.Google Scholar
Simon, , Fincher, S., Robins, A., Baker, B., Box, I., Cutts, Q., de Raadt, M., Haden, P., Hamer, J., Hamilton, M., Lister, R., Petre, M., Sutton, K., Tolhurst, D., & Tutty, J. (2006). Predictors of success in a first programming course. In Proceedings of the 8th Australasian Conference on Computing Education Volume 52 (pp. 189–196). Darlinghurst, Australia: Australian Computer Society,Google Scholar
Soloway, E., Ehrlich, K., Bonar, J., & Greenspan, J. (1983). What do novices know about programming? In Shneiderman, B. & Badre, A. (Eds.), Directions in Human–Computer Interactions (pp. 27–54). Norwood, NJ: Ablex.Google Scholar
Soloway, E. (1986). Learning to program = learning to construct mechanisms and explanations. Communications of the ACM, 29(9), 850–858.Google Scholar
Soloway, E., & Ehrlich, K. (1984). Empirical studies of programming knowledge. IEEE Transactions on Software Engineering, 5, 595–609.Google Scholar
Soloway, E., & Spohrer, J. C. (Eds.) (1989). Studying the Novice Programmer. Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
Sorva, J. (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 (pp. 21–30). New York: ACM.Google Scholar
Sorva, J. (2012). Visual Program Simulation in Introductory Programming Education (doctoral dissertation 61/2012). Aalto University.Google Scholar
Sorva, J. (2013). Notional machines and introductory programming education. ACM Transactions on Computing Education (TOCE), 13(2), 8.Google Scholar
Spohrer, J. C., & Soloway, E. (1989). Novice mistakes: Are the folk wisdoms correct? In Soloway, E. & Spohrer, J. C. (Eds.), Studying the Novice Programmer (pp. 401–416). Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
Spohrer, J. C., Soloway, E., & Pope, E. (1989). A goal/plan analysis of buggy Pascal programs. In Soloway, E. & Spohrer, J. C. (Eds.), Studying the Novice Programmer (pp. 355–399). Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
Stachel, J., Marghitu, D., Brahim, T. B., Sims, R., Reynolds, L., & Czelusniak, V. (2013). Managing cognitive load in introductory programming courses: A cognitive aware scaffolding tool. Journal of Integrated Design and Process Science, 17(1), 37–54.Google Scholar
Starr, C. W., Manaris, B., & Stalvey, R. H. (2008). Bloom’s taxonomy revisited: Specifying assessable learning objectives in computer science. ACM SIGCSE Bulletin, 40(1), 261–265.Google Scholar
Storey, M. A., Fracchia, F. D., & Müller, H. A. (1999). Cognitive design elements to support the construction of a mental model during software exploration. Journal of Systems and Software, 44(3), 171–185.Google Scholar
Subramanian, A., & Joshi, K. (1996). Computer aptitude tests as predictors of novice computer programmer performance. Journal of Information Technology Management, 7, 31–41.Google Scholar
Sweller, J. (1988). Cognitive load during problem solving: Effects on learning. Cognitive Science, 12(2), 257–285.Google Scholar
Sweller, J. (1994). Cognitive load theory, learning difficulty, and instructional design. Learning and Instruction, 4(4), 295–312.Google Scholar
Teague, D. (2015) Neo-Piagetian Theory and the Novice Programmer (doctoral thesis). Queensland University of Technology.Google Scholar
Teague, M. M. (2011). Pedagogy of Introductory Computer Programming: A People-First Approach (master’s thesis). Queensland University of Technology.Google Scholar
Thompson, E., Luxton-Reilly, A., Whalley, J. L., Hu, M., & Robbins, P. (2008). Bloom’s taxonomy for CS assessment. In Proceedings of the Tenth Conference on Australasian Computing Education (ACE ‘08) (pp. 155–161). Darlinghurst, Australia: Australian Computer Society.Google Scholar
Utting, I., Tew, A. E., McCracken, M., Thomas, L., Bouvier, D., Frye, R., Paterson, J., Caspersen, M., Kolikant, Y., Sorva, J., & Wilusz, T. (2013). A fresh look at novice programmers’ performance and their teachers’ expectations. In Proceedings of the ITICSE Working Group Reports Conference on Innovation and Technology in Computer Science Education (pp. 15–32). New York: ACM.Google Scholar
van Merriënboer, J. J. G. (1990). Strategies for programming instruction in high school: Program completion vs. program generation. Journal of Educational Computing Research, 6(3), 265–285.Google Scholar
van Merriënboer, J. J. G., & de Croock, M. B. M. (1992). Strategies for computer–based programming instruction: Program completion vs. program generation. Journal of Educational Computing Research, 8(3), 365–394.CrossRefGoogle Scholar
van Merriënboer, J. J., & Paas, F. G. (1990). Automation and schema acquisition in learning elementary computer programming: Implications for the design of practice. Computers in Human Behavior, 6(3), 273–289.Google Scholar
Venables, A., Tan, G., & Lister, R. (2009). A closer look at tracing, explaining and code writing skills in the novice programmer. In Proceedings of the Fifth International Workshop on Computing Education Research (pp. 117–128). New York: ACM.Google Scholar
Ventura, P. (2005). Identifying predictors of success for an objects-first CS1. Computer Science Education, 15(3), 223–243.Google Scholar
Vihavainen, A., Airaksinen, J., & Watson, C. (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 (pp. 19–26). New York: ACM.Google Scholar
Watson, C., & Li, F. W. (2014). Failure rates in introductory programming revisited. In Proceedings of the 2014 Conference on Innovation & Technology in Computer Science Education (pp. 39–44). New York: ACM.Google Scholar
Webster, B. F. (1996). The real software crisis: The shortage of top-notch programmers threatens to become the limiting factor in software development. Byte Magazine, 21, 218.Google Scholar
Weinberg, G. M. (1971). The Psychology of Computer Programming. New York: Van Nostrand Reinhold.Google Scholar
Weintrop, D., & Wilensky, U. (2015). To block or not to block, that is the question: Students’ perceptions of blocks-based programming. In Proceedings of the 14th International Conference on Interaction Design and Children (pp. 199–208). New York: ACM.Google Scholar
Weintrop, D., Killen, H., & Franke, B. (2018). Blocks or Text? How Programming Language Modality Makes a Difference in Assessing Underrepresented Populations. In Proceedings of the 13th International Conference of the Learning Sciences (ICLS2018) (pp. 328–335). London, UK: International Society of the Learning Sciences.Google Scholar
Werth, L. H. (1986). Predicting student performance in a beginning computer science class. ACM SIGCSE Bulletin, 18(1), 138–143.Google Scholar
Whalley, J. L., Lister, R., Thompson, E., Clear, T., Robbins, P., Ajith Kumar, P. K., & Prasad, C. (2006). An Austalasian study of reading and comprehension skills in novice programmers, using the Bloom and SOLO taxonomies. In Proceedings of the 8th Australian Conference on Computing Education (ACE ‘06) (pp. 243–252). Darlinghurst, Australia: Australian Computer Society.Google Scholar
White, G., & Sivitanides, M. (2002). A theory of the relationships between cognitive requirements of computer programming languages and programmers’ cognitive characteristics. Journal of Information Systems Education, 13(1), 59–66.Google Scholar
Wick, M. R. (2005). Teaching design patterns in CS1: A closed laboratory sequence based on the game of life. ACM SIGCSE Bulletin, 37(1), 487–491.Google Scholar
Widowski, D., & Eyferth, K. (1986). Comprehending and recalling computer programs of different structural and semantic complexity by experts and novices. In Willumeit, H. P. (Ed.), Human Decision Making and Manual Control (pp. 267–275). Amsterdam, The Netherlands: North–Holland, Elsevier.Google Scholar
Wiedenbeck, S., Fix, V., & Scholtz, J. (1993). Characteristics of the mental representations of novice and expert programmers: An empirical study. International Journal of Man–Machine Studies, 25, 697–709.Google Scholar
Wiedenbeck, S., & Ramalingam, V. (1999). Novice comprehension of small programs written in the procedural and object-oriented styles. International Journal of Human–Computer Studies, 51(1), 71–87.Google Scholar
Wiedenbeck, S., Ramalingam, V., Sarasamma, S., & Corritore, C. L. (1999). A comparison of the comprehension of object-oriented and procedural programs by novice programmers. Interacting with Computers, 11(3), 255–282.Google Scholar
Wileman, S. A., Konvalina, J., & Stephens, L. J. (1981). Factors influencing success in beginning computer science courses. Journal of Educational Research, 74, 223–226.Google Scholar
Wilson, B. C., & Shrock, S. (2001). Contributing to success in an introductory computer science course: A study of twelve factors. ACM SIGCSE Bulletin, 33(1), 184–188.Google Scholar
Winslow, L. E. (1996) Programming pedagogy – A psychological overview. ACM SIGCSE Bulletin, 28(3), 17–22.Google Scholar
Woszczynski, A., Haddad, H., & Zgambo, A. (2005). Towards a model of student success in programming courses. In Proceedings of the 43rd Annual Southeast Regional Conference – Volume 1 (ACM-SE 43) (pp. 301–302). New York: ACM.Google Scholar
Yadin, A. (2011). Reducing the dropout rate in an introductory programming course. ACM Inroads, 2(4), 71–76.Google Scholar
Yadin, A. (2013). Using unique assignments for reducing the bimodal grade distribution. ACM Inroads, 4(1), 38–42.Google Scholar

Save book to Kindle

To save this book to your Kindle, first ensure coreplatform@cambridge.org is added to your Approved Personal Document E-mail List under your Personal Document Settings on the Manage Your Content and Devices page of your Amazon account. Then enter the ‘name’ part of your Kindle email address below. Find out more about saving to your Kindle.

Note you can select to save to either the @free.kindle.com or @kindle.com variations. ‘@free.kindle.com’ emails are free but can only be saved to your device when it is connected to wi-fi. ‘@kindle.com’ emails can be delivered even when you are not connected to wi-fi, but note that service fees apply.

Find out more about the Kindle Personal Document Service.

Available formats
×

Save book to Dropbox

To save content items to your account, please confirm that you agree to abide by our usage policies. If this is the first time you use this feature, you will be asked to authorise Cambridge Core to connect with your account. Find out more about saving content to Dropbox.

Available formats
×

Save book to Google Drive

To save content items to your account, please confirm that you agree to abide by our usage policies. If this is the first time you use this feature, you will be asked to authorise Cambridge Core to connect with your account. Find out more about saving content to Google Drive.

Available formats
×