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-848d4c4894-pftt2 Total loading time: 0 Render date: 2024-06-04T05:57:16.730Z Has data issue: false hasContentIssue false

13 - Programming Paradigms and Beyond

from Systemic Issues

Published online by Cambridge University Press:  15 February 2019

By
Shriram Krishnamurthi  and
Kathi Fisler
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

Programming is a central concern of computer science, so its medium—programming languages—should be a focus of computing education. Unfortunately, much of the community lacks useful tools to understand and organize languages, since the standard literature is mired in the ill-defined and even confusing concept of paradigms. This chapter suggests the use of notional machines, i.e., human-accessible operational semantics, as a central organizing concept for understanding languages. It introduces or re-examines several concepts in programming and languages, especially state, whose complexity is understood well in the programming languages literature but is routinely overlooked in computing education. It identifies and provides context for numerous open problems worthy of research focus, some of which are new twists on long-running debates while others have not received the attention in the literature that they deserve.
Type
Chapter
Information
The Cambridge Handbook of Computing Education Research , pp. 377 - 413
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

Abelson, H., & Sussman, G. J. (1985). Structure and Interpretation of Computer Programs. Cambridge, MA: MIT Press.Google Scholar
Altadmri, A., & Brown, N. C. (2015). 37 million compilations: Investigating novice programming mistakes in large-scale student data. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 522–527). New York: ACM.Google Scholar
Armoni, M., Meerbaum-Salant, O., & Ben-Ari, M. (2015). From Scratch to “real” programming. Transactions on Computing Education (TOCE), 14(4), 25:1–25:15.Google Scholar
Bailie, F., Courtney, M., Murray, K., Schiaffino, R., & Tuohy, S. (2003). Objects first – Does it work? Journal of Computing Sciences in Small Colleges, 19(2), 303–305.Google Scholar
Bainomugisha, E., Carreton, A. L., van Cutsem, T., Mostinckx, S., & de Meuter, W. (2013). A survey on reactive programming. ACM Computing Surveys, 45(4), 52:1–52:34.CrossRefGoogle Scholar
Baker, C. M., Milne, L. R., & Ladner, R. E. (2015). StructJumper: A Tool to Help Blind Programmers Navigate and Understand the Structure of Code. In Proceedings of the ACM Conference on Human Factors in Computing Systems (pp. 3043–3052). New York: ACM.Google Scholar
Barik, T., Witschey, J., Johnson, B., & Murphy-Hill, E. (2014). Compiler error notifications revisited: An interaction-first approach for helping developers more effectively comprehend and resolve error notifications. In Companion Proceedings of the 36th International Conference on Software Engineering (ICSE Companion) (pp. 536–539). New York: ACM.Google Scholar
Barik, T., Smith, J., Lubick, K., Holmes, E., Feng, J., Murphy-Hill, E., & Parnin, C. (2017). Do developers read compiler error messages? In International Conference on Software Engineering (ICSE) (pp. 575–585). New York: IEEE Press.Google Scholar
Bau, D., Bau, D. A., Dawson, M., & Pickens, C. S. (2015). Pencil code: Block code for a text world. In Proceedings of the International Conference on Interaction Design and Children (pp. 445–448). New York, NY: ACM.Google Scholar
Begel, A., & Graham, S. L. (2005). Spoken programs. In IEEE Symposium on Visual Languages and Human-Centric Computing (VLHCC) (pp. 99–106). New York: IEEE Press.Google Scholar
Bennedsen, J., & Schulte, C. (2007). What does “objects-first” mean?: An international study of teachers’ perceptions of objects-first. In Proceedings of the Koli Calling Conference on Computing Education (pp. 21–29). Sydney, Australia: Australian Computer Society, Inc.Google Scholar
Bootstrap (2017). The Bootstrap Blog–Accessibility (Part 2): Images. Retrieved from www.bootstrapworld.org/blog/accessibility/Describing-Images-Screenreaders.shtmlGoogle Scholar
Bootstrap (2018). Data Science Curriculum (Spring 2018 edition). Retrieved from www.bootstrapworld.org/materials/spring2018/courses/data-science/english/Google Scholar
Brilliant, S. S., & Wiseman, T. R. (1996). The first programming paradigm and language dilemma. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 338–342). New York: ACM.Google Scholar
Bruce, K. B. (2005). Controversy on how to teach CS 1: A discussion on the SIGCSE-members mailing list. SIGCSE Bulletin, 37(2), 111–117.CrossRefGoogle Scholar
Cartwright, M. (1998). An empirical view of inheritance. Information and Software Technology, 40(14), 795–799.Google Scholar
Code.org (n.d.). Computer Science in Algebra. Retrieved from https://code.org/curriculum/algebraGoogle Scholar
Cooper, G. H., Guha, A., Krishnamurthi, S., McCarthy, J., & Findler, R. B. (2013). Teaching garbage collection without implementing compilers or interpreters. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 385–390). New York: ACM.Google Scholar
Cooper, K. D., Hall, M. W., Hood, R. T., Kennedy, K., McKinley, K. S., Mellor-Crummey, J. M., Torczon, L., & Warren, S. K. (1993). The ParaScope parallel programming environment. Proceedings of the IEEE, 81(2), 244–263.Google Scholar
Cooper, S., Dann, W., & Pausch, R. (2003). Teaching objects-first in introductory computer science. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 191–195). New York: ACM.Google Scholar
Dann, W., Cosgrove, D., Slater, D. Culyba, D., & Cooper, S. (2012). Mediated transfer: Alice 3 to Java. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 141–146). New York: ACM.Google Scholar
de Raadt, M., Watson, R., & Toleman, M. (2002). Language trends in introductory programming courses. In Proceedings of Informing Science (pp. 329–337). Santa Rosa, CA: Informing Science Institute.Google Scholar
de Raadt, M., Watson, R., & Toleman, M. (2009). Teaching and assessing programming strategies explicitly. In Proceedings of the Australasian Computing Education Conference (ACE) (pp. 45–54). Sydney, Australia: Australian Computer Society, Inc.Google Scholar
Dean, J., & Ghemawat, S. (2008). MapReduce: simplified data processing on large clusters. In Communications of the ACM, 51(1), 107–113.CrossRefGoogle Scholar
Decker, R., & Hirshfield, S. (1994). The top 10 reasons why object-oriented programming can’t be taught in CS 1. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 51–55). New York: ACM.Google Scholar
Denny, P., Luxton-Reilly, A., & Carpenter, D. (2014). Enhancing syntax error messages appears ineffectual. In Proceedings of the SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE) (pp. 273–278). New York: ACM.Google Scholar
DiSalvo, B. (2012). Glitch game testers: the design and study of a learning environment for computational production with young African American males (PhD thesis). Georgia Institute of Technology.Google Scholar
diSessa, A. A., & Abelson, H. (1986). Boxer: A reconstructible computational medium. Communications of the ACM, 29(9), 859–868.Google Scholar
Dix, A. J. (2013). Formal methods. In The Encyclopedia of Human–Computer Interaction, 2nd edn. Aarhus, Denmark: The Interaction Design Foundation, Article 29.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., O’Shea, T., & Monk, J. (1999). The black box inside the glass box. International Journal of Human–Computer Studies, 51(2), 265–277.CrossRefGoogle Scholar
Ebrahimi, A. (1994). Novice programmer errors: language constructs and plan composition. International Journal of Human–Computer Studies, 41, 457–480.Google Scholar
Eckerdal, A., & Thune, M. (2005). Novice Java programmers conceptions of object and class, and variation theory. SIGCSE Bulletin, 37(3), 89–93.CrossRefGoogle Scholar
Ehlert, A., & Schulte, C. (2009). Empirical comparison of objects-first and objects-later. In Proceedings of the Conference on International Computing Education Research (ICER) (pp. 15–26). New York: ACM.Google Scholar
Felleisen, M., & Hieb, R. (1992). The revised report on the syntactic theories of sequential control and state. Theoretical Computer Science, 102, 235–271.Google Scholar
Felleisen, M., Findler, R. B., Flatt, M., & Krishnamurthi, S. (2001). How to Design Programs. Cambridge, MA: MIT Press.Google Scholar
Felleisen, M., Findler, R. B., Flatt, M. & Krishnamurthi, S. (2009). A functional I/O system or, fun for freshman kids. In Proceedings of the 14th ACM SIGPLAN International Conference on Functional Programming (ICFP ‘09) (pp. 47–58). New York, NY: ACM.Google Scholar
Felleisen, M., Findler, R. B., Flatt, M., & Krishnamurthi, S. (2014). How to Design Programs, 2nd edn. Cambridge, MA: MIT Press.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 Conference on International Computing Education Research (ICER) (pp. 35–42). New York: ACM.Google Scholar
Fisler, K., Krishnamurthi, S., & Siegmund, J. (2016). Modernizing plan-composition studies. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 211–216). New York: ACM.Google Scholar
Fisler, K., Krishnamurthi, S., & Tunnell Wilson, P. (2017). Assessing and teaching scope, mutation, and aliasing in upper-level undergraduates. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 213–218). New York: ACM.Google Scholar
Fitter, M. (1979). Towards more natural interactive systems. International Journal of Man-Machine Studies, 11(3), 339–350.Google Scholar
Fitzgerald, S., Lewandowski, G., McCauley, R., Murphy, L., Simon, B., Thomas, L., & Zander, C. (2008). Debugging: finding, fixing and flailing, a multi-institutional study of novice debuggers. Computer Science Education, 18(2), 93–116.CrossRefGoogle Scholar
Flatt, M., Krishnamurthi, S., & Felleisen, M. (1998). Classes and mixins. In ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (pp. 171–183). New York: ACM.Google Scholar
Fleury, A. E. (1991). Parameter passing: The rules the students construct. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 283–286). New York: ACM.Google Scholar
Freeman, S., Eddy, S. L., McDonough, M., Smith, M. K., Okoroafor, N., Jordt, H., & Wenderotha, M. P. (2014). Active learning increases student performance in science, engineering, and mathematics. Proceedings of the National Academy of Sciences of the United States of America, 111(23), 8410–8415.Google Scholar
Goldman, K., Gross, P., Heeren, C., Herman, G. L., Kaczmarczyk, L., Loui, M. C., & Zilles, C. (2010). Setting the scope of concept inventories for introductory computing subjects. Transactions on Computing Education (TOCE), 10(2), 5:1–5:29.Google Scholar
Gosling, J., Joy, B., Steele, Jr., G. L., Bracha, G., & Buckley, A. (2015). The Java Language Specification, Java SE 8 Edition. Redwood Shores, CA: Oracle America, Inc.Google Scholar
Green, C. C. (1969). Application of theorem proving to problem solving. In International Joint Conference on Artificial Intelligence (pp. 219–239). San Francisco, CA: Morgan Kaufmann Publishers Inc.Google Scholar
Greening, T. (1999). Emerging constructivist forces in computer science education: Shaping a new future. In Greening, T. (Ed.), Computer Science Education in the 21st Century (pp. 47–80). Berlin, Germany: Springer.Google Scholar
Grover, S., & Basu, S. (2017). Measuring student learning in introductory block-based programming: Examining misconceptions of loops, variables, and Boolean logic. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 267–272). New York: ACM.Google Scholar
Guha, A., Saftoiu, C., & Krishnamurthi, S. (2010). The essence of JavaScript. In European Conference on Object-Oriented Programming (ECOOP) (pp. 126–150). Berlin, Germany: Springer-Verlag.Google Scholar
Gulwani, S., Polozov, O., & Singh, R. (2017). Program synthesis. Foundations and Trends in Programming Languages, 4(1–2), 1–119.Google Scholar
Gupta, A., Hammer, D., & Redish, E. F. (2010). The case for dynamic models of learners’ ontologies in physics. Journal of the Learning Sciences, 19, 285–321.Google Scholar
Guzdial, M. (2015). Learner-Centered Design of Computing Education: Research on Computing for Everyone. San Rafael, CA: Morgan and Claypool.Google Scholar
Haarslev, V. (1995). Formal semantics of visual languages using spatial reasoning. In Proceedings of the IEEE Symposium on Visual Languages (pp. 156–163). New York: IEEE Press.Google Scholar
Harvey, B. (1993. Discussion forum comment on comp. lang. scheme. Retrieved from https://groups.google.com/forum/#!msg/comp.lang.scheme/zZRSDcZdV2M/MZJLiU6gE64JGoogle Scholar
Harvey, B., & Wright, M. (1999). Simply Scheme: Introducing Computer Science, 2nd edn. Cambridge, MA: MIT Press.Google Scholar
Holt, R. C., & Wortman, D. B. (1974). A sequence of structured subsets of PL/I. SIGCSE Bulletin, 6(1), 129–132.Google Scholar
Homer, M., & Noble, J. (2014). Combining tiled and textual views of code. In IEEE Working Conference on Software Visualization (VISSOFT) (pp. 1–10). New York: IEEE Press.Google Scholar
Hristova, M., Misra, A., Rutter, M., & Mercuri, R. (2003). Identifying and correcting Java programming errors for introductory computer science students. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE). New York: ACM.Google Scholar
Hu, C. (2004). Rethinking of teaching objects-first. Education and Information Technologies, 9(3), 209–218.Google Scholar
Hundhausen, C. D., Douglas, S. A., & Stasko, J. T. (2002). A meta-study of algorithm visualization effectiveness. Journal of Visual Languages and Computing, 13(3), 259–290.Google Scholar
Jackson, J., Cobb, M., & Carver, C. (2005). Identifying top Java errors for novice programmers. In Frontiers in Education (FIE ‘05) (pp. T4C:24-T4C:27). New York, NY: IEEE.Google Scholar
Jadud, M. C. (2006). Methods and tools for exploring novice compilation behaviour. In Proceedings of the Conference on International Computing Education Research (ICER) (pp. 73–84). New York: ACM.Google Scholar
Johnson, L. F. (1995). C in the first course considered harmful. Communications of the ACM, 38(5), 99–101.Google Scholar
Kahn, K. M., & Saraswat, V. A. (1990). Complete Visualizations of Concurrent Programs and Their Executions. Tech. Rept. SSL-90-38 [P90-00099]. Palo Alto, CA: Xerox Palo Alto Research Center.Google Scholar
Kay, A. C. (1993). The early history of Smalltalk. In ACM SIGPLAN Conference on History of Programming Languages (pp. 69–95). New York: ACM.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, 37(2), 83–137.Google Scholar
Kessel, C. J., & Wickens, C. D. (1982). The transfer of failure-detection skills between monitoring and controlling dynamic systems. Human Factors, 24(1), 49–60.Google Scholar
Ko, A. J., Myers, B. A., & Aung, H. (2004). Six learning barriers in end-user programming systems. In IEEE Symposium on Visual Languages and Human-Centric Computing (VLHCC) (pp. 199–206). New York: IEEE Press.Google Scholar
Kölling, M., Brown, , , N. C. C., & Altadmri, A. (2015). Frame-based editing: Easing the transition from blocks to text-based programming. In Workshop in Primary and Secondary Computing Education (pp. 29–38). New York, NY: ACM.Google Scholar
Krishnamurthi, S. (2006). Programming Languages: Application and Interpretation. Retrieved from www.cs.brown.edu/~sk/Publications/Books/ProgLangs/Google Scholar
Krishnamurthi, S. (2008). Teaching programming languages in a post-Linnaean age. In SIGPLAN Notices, 43(11), 81–83.Google Scholar
Lee, M. J., & Ko, A. J. (2011). Personifying programming tool feedback improves novice programmers’ learning. In Proceedings of the Conference on International Computing Education Research (ICER) (pp. 109–116). New York: ACM.Google Scholar
Lewis, C., Esper, S., Bhattacharyya, V., Fa-Kaji, N., Dominguez, N., & Schlesinger, A. (2014). Children’s perceptions of what counts as a programming language. Journal of Computing Sciences in Colleges, 29(4), 123–133.Google Scholar
Lewis, C. M. (2010). How programming environment shapes perception, learning and goals: Logo vs. Scratch. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 346–350). New York: ACM.CrossRefGoogle Scholar
Lister, R., Berglund, A., Clear, T., Bergin, J., Garvin-Doxas, K., Hanks, B., Hitchner, L., Luxton-Reilly, A., Sanders, K., Schulte, C., & Whalley, J. L. (2006). Research perspectives on the objects-early debate. In Working Group Reports on ITiCSE on Innovation and Technology in Computer Science Education (pp. 146–165). New York: ACM.CrossRefGoogle Scholar
Ma, L. (2007). Investigating and Improving Novice Programmers Mental Models of Programming Concepts (PhD thesis). University of Strathclyde, Department of Computer & Information Sciences.Google Scholar
Mace, R. L., Hardie, G. J., & Place, J. P. (1991). Accessible environments: Toward universal design. In Preiser, W. E., Vischer, J. C., & White, E. T. (Eds.), Design Intervention: Toward a More Humane Architecture (pp. 155–176). Reinhold, NY: Van Nostrand.Google Scholar
Malan, D. J., & Leitner, H. H. (2007). Scratch for budding computer scientists. SIGCSE Bulletin, 39(1), 223–227.Google Scholar
Marceau, G., Fisler, K., & Krishnamurthi, S. (2011). Measuring the effectiveness of error messages designed for novice programmers. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 499–504). New York: ACM.Google Scholar
Mayer, R. E., & Moreno, R. (2003). Nine ways to reduce cognitive load in multimedia learning. Educational Psychologist, 38(1), 43–52.CrossRefGoogle Scholar
McCauley, R., Hanks, B., Fitzgerald, S., & Murphy, L. (2015). Recursion vs. iteration: An empirical study of comprehension revisited. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 350–355). New York: ACM.Google Scholar
Meerbaum-Salant, O., Armoni, M., & Ben-Ari, M. (2011). Habits of programming in Scratch. In Proceedings of the SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE) (pp. 168–172). New York: ACM.Google Scholar
Miller, L. A. (1974). Programming by non-programmers. International Journal of Man Machine Studies, 6, 237–260.Google Scholar
Miller, L. A. (1975). Naive programmer problems with specification of transfer-of-control. In Proceedings of the National Computer Conference and Exposition (pp. 657–663). New York: ACM.Google Scholar
Miller, L. A. (1981). Natural language programming: Styles, strategies, and contrasts. IBM Systems Journal, 20, 184–215.Google Scholar
Miller, M. S., Von Dincklage, D., Ercegovac, V., & Chin, B. (2017). Uncanny valleys in declarative language design. In LIPIcs-Leibniz International Proceedings in Informatics, Vol. 71 (pp. 9:1–9:12). Wadern, Germany: Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik.Google Scholar
Mönig, J., Ohshima, , , Y., & Maloney, J. (2015). Blocks at your fingertips: Blurring the line between blocks and text in GP. In Proceedings of the Blocks and Beyond Workshop (pp. 51–53). New York, NY: IEEE.Google Scholar
Muller, O., Ginat, D., & Haberman, B. (2007). Pattern-oriented instruction and its inuence on problem decomposition and solution construction. In Proceedings of the SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE) (pp. 151–155). New York: ACM.Google Scholar
Myers, B. A. (1991). Separating application code from toolkits: Eliminating the spaghetti of call-backs. In ACM Symposium on User Interface Software and Technology (pp. 211–220). New York: ACM.Google Scholar
Naps, T. L., Rössling, G., Almstrum, , Dann, V., Fleischer, W., Hundhausen, R., Korhonen, C., Malmi, A., McNally, L., Rodger, M., S., & Velázquez-Iturbide, J. A. (2003). Exploring the role of visualization and engagement in computer science education. SIGCSE Bulletin, 35(2), 131–152.Google Scholar
Nelson, G. L., Xie, B., & Ko, A. J. (2017). Comprehension first: Evaluating a novel pedagogy and tutoring system for program tracing in CS1. In Proceedings of the Conference on International Computing Education Research (ICER) (pp. 2–11). New York: ACM.Google Scholar
Nordström, M., & Börstler, J. (2011). Improving OO Example Programs. IEEE Transactions on Education, 54(10), 1–5.Google Scholar
Pane, J. F. (2002). A Programming System for Children That Is Designed for Usability (PhD thesis). Carnegie Mellon University, Computer Science Department.Google Scholar
Pane, J. F., Ratanamahatana, C., & Myers, B. A. (2001). Studying the language and structure in non-programmers’ solutions to programming problems. International Journal of Human-Computer Studies, 54(2), 237–264.CrossRefGoogle Scholar
Parker, M. C., Guzdial, M., & Engleman, S. (2016). Replication, Validation, and Use of a Language Independent CS1 Knowledge Assessment. In Proceedings of the 2016 ACM Conference on International Computing Education Research (ICER) (pp. 93–101). 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
Pettit, R. S., Homer, J., & Gee, R. (2017). Do enhanced compiler error messages help students?: Results inconclusive. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 465–470). New York: ACM.Google Scholar
Pirolli, P. L., & Anderson, J. R. (1985). The role of learning from examples in the acquisition of recursive programming skills. Canadian Journal of Psychology/Revue Canadienne de Psychologie, 39(2), 240–272.Google Scholar
Plotkin, G. D. (1975). Call-by-name, call-by-value, and the λ-calculus. Theoretical Computer Science, 1(2), 125–159.CrossRefGoogle Scholar
Plum, T. (1977). Fooling the user of a programming language. Software Practice and Experience, 7, 215–221.Google Scholar
Powers, K., Ecott, S., & Hirshfield, L. M. (2007). Through the looking glass: Teaching CS0 with Alice. SIGCSE Bulletin, 39(1), 213–217.Google Scholar
Price, T. W., Brown, N. C. C., Lipovac, D., Barnes, T., & Kölling, M. (2016). Evaluation of a frame-based programming editor. In Proceedings of the Conference on International Computing Education Research (ICER) (pp. 32–42). New York: ACM.Google Scholar
Reges, S. (2006). Back to basics in CS1 and CS2. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 293–297). New York: ACM.Google Scholar
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., Millner, A., Rosenbaum, E., Silver, J., Silverman, B., & Kafai, Y. (2009). Scratch: Programming for all. Communications of the ACM, 52(11), 80–87.CrossRefGoogle Scholar
Rist, R. S. (1991). Knowledge creation and retrieval in program design: A comparison of novice and intermediate student programmers. Human–Computer Interaction, 6(1), 1–46.Google Scholar
Rivers, K., & Koedinger, K. R. (2015). Data-driven hint generation in vast solution spaces: A self-improving Python programming tutor. International Journal of Artificial Intelligence in Education, 27(1), 1–28.Google Scholar
Sajaniemi, J., & Kuittinen, M. (2008). From procedures to objects: A research agenda for the psychology of object-oriented programming education. Human Technology, 4(1), 75–91.Google Scholar
Savery, J. R., & Duffy, T. M. (2001). Problem Based Learning: An Instructional Model and Its Constructivist Framework. Tech. Rept. 16-01. Bloomington, IN: Indiana University Center for Research on Learning and Technology.Google Scholar
Schanzer, E., Krishnamurthi, S., & Fisler, K. (2015). Blocks versus text: Ongoing lessons from Bootstrap. In Proceedings of the Blocks and Beyond Workshop (pp. 125–126). New York, NY: IEEE.Google Scholar
Scholtz, J., & Wiedenbeck, S. (1990). Learning second and subsequent programming languages: A problem of transfer. International Journal of Human-Computer Interaction, 2(1), 51–72.Google Scholar
Schumacher, R. M., & Czerwinski, M. P. (1992). Mental models and the acquisition of expert knowledge. In Hoffman, R. R. (Ed.), The Psychology of Expertise: Cognitive Research and Empirical AI (pp. 61–79). Berlin, Germany: Springer.Google Scholar
Schwill, A. (1994). Fundamental ideas of computer science. Bulletin of the European Association for Theoretical Computer Science, 53, 274–274.Google Scholar
Seppälä, O., Ihantola, , Isohanni, P., Sorva, E., , J., & Vihavainen, A. (2015). Do we know how difficult the rainfall problem is? In Proceedings of the Koli Calling Conference on Computing Education (pp. 87–96). New York: ACM.Google Scholar
Shinners-Kennedy, D. (2008). The everydayness of threshold concepts: State as an example from computer science. In Land, R. & Meyer, J. H. F. (Eds.), Threshold Concepts within the Disciplines (pp. 119–128). Rotterdam, The Netherlands: Sense Publishers.Google Scholar
Simon, (2013). Soloway’s Rainfall Problem has become harder. In LATICE '13 Proceedings of the 2013 Learning and Teaching in Computing and Engineering (pp. 130–135). Washington, DC: IEEE Computer Society.Google Scholar
Sirkiä, T., & Sorva, J. (2012). Exploring programming misconceptions: An analysis of student mistakes in visual program simulation exercises. In Proceedings of the Koli Calling Conference on Computing Education (pp. 19–28). New York: ACM.Google Scholar
Slotta, J. D., & Chi, M. T. H. (2006). The impact of ontology training on conceptual change: Helping students understand the challenging topics in science. Cognition and Instruction, 24, 261–289.Google Scholar
Smaragdakis, Y., & Balatsouras, G. (2015). Pointer analysis. Foundations and Trends in Programming Languages, 2(1), 1–69.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., Bonar, J., & Ehrlich, K. (1983). Cognitive strategies and looping constructs: An empirical study. Communications of the ACM, 26(11), 853–860.Google Scholar
Somers, J. (2017). The coming software apocalypse. The Atlantic, Sept. Retrieved from www.theatlantic.com/technology/archive/2017/09/saving-the-world-from-code/540393/Google Scholar
Sorva, J. (2012). Visual Program Simulation in Introductory Programming Education (PhD thesis). Aalto University, Department of Computer Science and Engineering.Google Scholar
Sorva, J. (2013). Notional machines and introductory programming education. Transactions on Computing Education (TOCE), 13(2), 8:1–8:31.Google Scholar
Spohrer, J. C., & Soloway, E. (1989). Simulating Student Programmers (pp. 543–549). Morgan Kaufmann Publishers, Inc. San Francisco, CA, USA.Google Scholar
Stanton, J., Goldsmith, L., Adrion, W. R., Dunton, S., Hendrickson, K. A., Peterfreund, A., Youngpradit, P., Zarch, R., & Zinth, J. D. (2017). State of the States Landscape Report: State-Level Policies Supporting Equitable K12 Computer Science Education. Retrieved from www.edc.org/sites/default/files/uploads/State-States-Landscape-Report.pdfGoogle Scholar
Stefik, A., & Gellenbeck, E. (2009). Using spoken text to aid debugging: An empirical study. In IEEE International Conference on Program Comprehension (pp. 110–119). New York: IEEE Press.Google Scholar
Stefik, A., & Gellenbeck, E. (2011). Empirical studies on programming language stimuli. Software Quality Journal, 19(1), 65–99.Google Scholar
Stefik, A., & Siebert, S. (2013). An empirical investigation into programming language syntax. Transactions on Computing Education (TOCE), 13(4), 19:1–19:40.Google Scholar
Stefik, A., Hundhausen, C., & Patterson, R. (2011). An empirical investigation into the design of auditory cues to enhance computer program comprehension. International Journal of Human–Computer Studies, 69(12), 820–838.Google Scholar
Stefik, A. M. (2008). On the Design of Program Execution Environments for Non-Sighted Computer Programmers (PhD thesis). Washington State University.Google Scholar
Sudol, L. A. (2011). Deepening Students Understanding of Algorithms: Effects of Problem Context and Feedback Regarding Algorithmic Abstraction (PhD thesis). Carnegie Mellon University.Google Scholar
Tessler, J., Beth, B., & Lin, C. (2013). Using Cargo-bot to provide contextualized learning of recursion. In Proceedings of the Conference on International Computing Education Research (ICER) (pp. 161–168). New York: ACM.Google Scholar
Tew, A. E., McCracken, W. M., & Guzdial, M. (2005). Impact of alternative introductory courses on programming concept understanding. In Proceedings of the Conference on International Computing Education Research (ICER) (pp. 25–35). New York: ACM.Google Scholar
The College Board (n.d.). AP Computer Science Principles: Course Overview. Retrieved from https://apstudent.collegeboard.org/apcourse/ap-computer-science-principlesGoogle Scholar
Tichy, W. F., & Prechelt, L. (1998). A controlled experiment to assess the benefits of procedure argument type checking. IEEE Transactions on Software Engineering, 24(4), 302–312.Google Scholar
Tirronen, V., Uusi-Mäakelä, S., & Isomöttönen, V. (2015). Understanding beginners’ mistakes with Haskell. Journal of Functional Programming, 25, e11.Google Scholar
Traver, V. J. (2010). On compiler error messages: What they say and what they mean. Advances in Human–Computer Interaction, 2010, 602570.Google Scholar
Tunnell Wilson, P., Pombrio, J., & Krishnamurthi, S. (2017). Can we crowdsource language design? In Proceedings of SPLASH Onward (Onward! ‘17) (17 pages). Vancouver, Canada: Onward.Google Scholar
Tunnell Wilson, P., Fisler, K., & Krishnamurthi, S. (2017). Student understanding of aliasing and procedure calls. In SPLASH Education Symposium (SPLASH-E ‘17) (6 Pages). New York, NY: ACM.Google Scholar
Tunnell Wilson, P., Krishnamurthi, S., & Fisler, K. (2018). Evaluating the tracing of recursion in the substitution notional machine. In Proceedings of the ACM Symposium on Computer Science Education (SIGCSE) (pp. 1023–1028). New York: ACM.Google Scholar
Vasek, M. (2012). Representing Expressive Types in Blocks Programming Languages. Retrieved from https://repository.wellesley.edu/thesiscollection/24/Google Scholar
Vickers, P., & Alty, J. L. (2002). When bugs sing. Interacting with Computers, 14(6), 793–819.Google Scholar
Victor, B. (2012). Learnable Programming: Designing a Programming System for Understanding Programs. Retrieved from http://worrydream.com/#!/LearnableProgrammingGoogle Scholar
Vilner, T., Zur, E., & Gal-Ezer, J. (2007). Fundamental concepts of CS1: Procedural vs. object oriented paradigm – A case study. SIGCSE Bulletin, 39(3), 171–175.Google Scholar
Wand, M. (1986). Finding the source of type errors. In ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (pp. 38–43). New York: ACM.Google Scholar
Weintrop, D., & Wilensky, U. (2015a). To block or not to block, that is the question: Students perceptions of blocks-based programming. In Proceedings of the International Conference on Interaction Design and Children (pp. 199–208). New York, NY: ACM.Google Scholar
Weintrop, D., & Wilensky, U. (2015b). Using commutative assessments to compare conceptual understanding in blocks-based and text-based programs. In Proceedings of the Conference on International Computing Education Research (ICER). New York: ACM.Google Scholar
Weintrop, D., & Wilensky, U. (2017a). Comparing blocks-based and text-based programming in high school computer science classrooms. Transactions on Computing Education (TOCE), 18(1), 3:1–3:25.Google Scholar
Weintrop, D., & Wilensky, U. (2017b). Between a block and a typeface: Designing and evaluating hybrid programming environments. In Proceedings of the International Conference on Interaction Design and Children (pp. 183–192). New York, NY: ACM.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.CrossRefGoogle 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

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
×