Novice Programmers and Introductory Programming

doi:10.1017/9781108654555.013

12 - Novice Programmers and Introductory Programming

from Systemic Issues

Published online by Cambridge University Press: 15 February 2019

Anthony V. Robins

Edited by

Sally A. Fincher and

Anthony V. Robins

Show author details

Sally A. Fincher: Affiliation:
University of Kent, Canterbury
Anthony V. Robins: Affiliation:
University of Otago, New Zealand

Book contents

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.

Information

Type: Chapter
Information: The Cambridge Handbook of Computing Education Research , pp. 327 - 376

DOI: https://doi.org/10.1017/9781108654555.013 [Opens in a new window]

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.)

Book purchase

Temporarily unavailable

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.CrossRef Google 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.CrossRef Google 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.CrossRef Google 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.pdf Google 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.CrossRef Google 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.CrossRef Google 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/standards Google 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.CrossRef Google 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/saeed Google Scholar

Dehnadi, S., & Bornat, R. (2006). The camel has two humps (working title). Retrieved from www.eis.mdx.ac.uk/research/PhDArea/saeed/paper1.pdf Google 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.CrossRef Google 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.pdf Google 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.CrossRef Google 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-programming Google 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.CrossRef Google 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.pdf Google 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.CrossRef Google 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

Accessibility standard: Unknown

Why this information is here

This section outlines the accessibility features of this content - including support for screen readers, full keyboard navigation and high-contrast display options. This may not be relevant for you.

Accessibility Information

Accessibility compliance for the HTML of this chapter is currently unknown and may be updated in the future.