pith. sign in

arxiv: 2606.12427 · v1 · pith:4GWLFB7Dnew · submitted 2026-05-14 · 💻 cs.CY

Planning on Paper: Problem Decomposition with Diagrams in Introductory Computing

Annapurna Vadaparty , Devamardeep Hayatpur , Adalbert Gerald Soosai Raj , Leo Porter , Daniel Zingaro This is my paper

Pith reviewed 2026-06-30 19:52 UTC · model grok-4.3

classification 💻 cs.CY
keywords problem decompositionnovice programmersCS1 educationdiagrammatic representationsthematic analysisfunction hierarchyplanning strategiesprogram behavior models
0
0 comments X

The pith

Novice programmers' decomposition diagrams reveal multiple underlying models of program behavior with tensions between structural hierarchy and execution sequencing.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Students in a CS1 lab drew pencil-and-paper diagrams to decompose a word-game program into functions and their relationships. Thematic analysis of 55 diagrams identified both hierarchical function structures and sequencing approaches, along with recurring issues in notation consistency, order of execution, abstraction, reuse, encapsulation, and problem-specific errors. The work establishes that these representations point to competing mental models novices hold about how programs operate. This matters because many educators now prioritize decomposition skills over code writing in light of generative AI tools. The findings therefore point toward targeted instructional changes in how planning is taught and supported.

Core claim

When CS1 students drew decomposition diagrams for a multifunction word-game program, they used both hierarchical function-call structures and sequencing of execution steps; diagrams frequently contained incompatible notations, unclear abstraction boundaries, missing reuse opportunities, and execution-order problems, indicating that novice decomposition is shaped by multiple models of program behavior with tensions between structural and sequence-focused reasoning.

What carries the argument

The pencil-and-paper decomposition diagram, which students used to externalize functions, their relationships, and execution order, serving as the primary data source for inductive thematic analysis.

If this is right

  • Decomposition instruction should address both hierarchical structure and sequential execution to reduce conflicts between the two models.
  • Explicit teaching of consistent notation conventions could reduce the incompatible-notation problems observed in student diagrams.
  • Future work on plan tracing through simulation may help students test and refine their decompositions before coding.
  • Instructional materials may need to target abstraction, reuse, and encapsulation skills separately from basic function identification.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same diagram-drawing task could be used across different problem domains to test whether the structural-versus-sequential tension appears only in game-like specifications.
  • Providing pre-drawn diagram templates might reveal whether the observed issues stem from lack of representational guidance or from deeper model conflicts.
  • If the multiple-models pattern holds, AI-assisted planning tools may need to support both structural and sequential views rather than enforcing a single format.

Load-bearing premise

The diagrams students produced are accurate externalizations of their internal decomposition thinking and the thematic coding process surfaces the main issues without substantial bias from the drawing medium or researcher interpretation.

What would settle it

A controlled follow-up in which students receive explicit instruction on one consistent diagram notation and then produce diagrams showing no mixed notations or order-of-execution errors would indicate the multiple-models tension is not inherent.

Figures

Figures reproduced from arXiv: 2606.12427 by Adalbert Gerald Soosai Raj, Annapurna Vadaparty, Daniel Zingaro, Devamardeep Hayatpur, Leo Porter.

Figure 1
Figure 1. Figure 1: An example of a hierarchical function call decomposition diagram from the course text￾book for a two-player dice game (Porter and Zingaro [36]). Our study draws from students in a large introductory CS1 course in Python that had been recently redesigned to include shifting core competencies in light of GenAI. The course taught debugging, testing, working with GenAI tools, and problem decomposition, as well… view at source ↗
Figure 2
Figure 2. Figure 2: An excerpt from our Evil Word Guesser task description given to students [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 4
Figure 4. Figure 4: A diagram showing functions making hierarchical function calls, i.e. arrows represent a function calling a helper. Purposes of each node are labeled in grey throughout this illustrative example (and both others). • Relation Types: The nodes are connected to each other with arrows indicating hierarchical function calls. For example, “play_evilhangman” is a function that calls three helper functions. • Issue… view at source ↗
Figure 5
Figure 5. Figure 5: A diagram showing functions connected by arrows that indicate sequencing of execution order. Most nodes are functions, with two data nodes (highlighted in red) representing input data. There are also two annotation nodes highlighted in green that handle condition/control flow, creating branching functionality. Less clearly specified are the relations that branch from the top-left input data node, which cre… view at source ↗
Figure 6
Figure 6. Figure 6: A diagram with clashing notations. The three relations leaving the main function indicate hierarchical function calls (highlighted in red) and the remaining three relations indicate sequencing (highlighted in green). The arrow from “check condition” to “display status” indicates that display status is next in a sequence, but display status was initially called by “main” in a hierarchical call. There is als… view at source ↗
Figure 7
Figure 7. Figure 7: A diagram with several issues. 1) Selects word families based on incorrect conditions by filtering for the number of occurrences of the guessed letter. 2) Clashing notations: the arrows on the left side (red, outgoing from main) indicate a hierarchical function call, while the rest indicate sequencing (green). 3) Poorly encapsulated loop : The rightmost node has looping language (“and repeats until word is… view at source ↗
Figure 8
Figure 8. Figure 8: A diagram with encapsulation and other issues. 1) An annotation node (highlighted in green) states that “Functions 2 + 3 would loop...”, where Function 2 generates word families and Function 3 selects the largest word family. This is a poorly encapsulated loop because it does not include getting the player’s guess, even though it should–the diagram should include the “Input Data” node in its loop. 2) There… view at source ↗
read the original abstract

Background and Context. Problem decomposition is a core concern of computing education. It has also become increasingly relevant: in response to GenAI, many CS1 educators are advocating for shifting instructional emphasis away from code writing and towards decomposition and higher-level planning. Currently, there is a lack of knowledge in how novices do decomposition in large, multifunction tasks. Objectives. In this study, we describe how students represent solutions to a decomposition task, and characterize common issues that arise in those representations. Method. In a 50-minute lab, students were given a description of a word game and asked to draw (with pencil and paper) a decomposition diagram for a program that would implement this game. We performed an inductive thematic analysis with negotiated agreement on 55 of the diagrams, coding salient elements (e.g. functions and the relationships between them) and issues that arose. Findings. Students used multiple representational strategies, including hierarchical function calls and sequencing (order of execution). We identified issues in notation (including use of differing, incompatible notations within the same diagram), order of execution, abstraction and reuse, encapsulation, clarity, and problem-specific misunderstandings. Implications. These findings suggest that novice decomposition is shaped by multiple underlying models of program behavior, with tensions between structural and sequence-focused reasoning. We discuss implications for decomposition instruction and future work, including clarifying representational constraints and plan tracing as simulation.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The paper reports an inductive thematic analysis with negotiated agreement of 55 pencil-and-paper decomposition diagrams produced by introductory computing students in a 50-minute lab task involving a word game. Students employed multiple representational strategies (hierarchical function calls and sequencing of execution order); the analysis identifies recurring issues in notation (including mixed incompatible notations), order of execution, abstraction/reuse, encapsulation, clarity, and problem-specific misunderstandings. The authors conclude that these patterns indicate novice decomposition is shaped by multiple underlying models of program behavior, with tensions between structural and sequence-focused reasoning, and discuss implications for decomposition instruction.

Significance. If the mapping from static diagrams to cognitive models is valid, the study supplies a concrete descriptive account of how novices externalize decomposition in a multifunction task, which is timely for CS1 instruction emphasizing planning over code writing. The negotiated-agreement thematic analysis on authentic student artifacts is a strength, though the absence of validation data limits the strength of the cognitive-model claims.

major comments (2)
  1. [Findings / Implications] Findings and Implications sections: The claim that observed strategies reflect 'tensions between structural and sequence-focused reasoning' and 'multiple underlying models of program behavior' rests on an unvalidated interpretive mapping from static diagrams to internal cognitive models. The reported procedure (inductive coding of salient elements and issues on 55 diagrams) does not include think-aloud protocols, interviews, or member-checking that would distinguish representational choices from pre-existing models of program behavior.
  2. [Method] Method section: The description of the inductive thematic analysis supplies only high-level information on coding of salient elements and issues. Specific coding criteria, decision rules for distinguishing problem-specific misunderstandings from general issues, and the precise process for negotiated agreement are not reported, which bears on the reliability of the thematic categories that support the central claim.
minor comments (2)
  1. [Abstract] Abstract: The method paragraph could state the exact task prompt and sample demographics to allow readers to assess generalizability without consulting the full text.
  2. The paper would benefit from one or two additional example diagrams (with annotations) that illustrate the distinction between hierarchical and sequencing strategies.

Simulated Author's Rebuttal

2 responses · 1 unresolved

We thank the referee for their constructive comments, which highlight important limitations in the interpretive scope and methodological transparency of our work. We address each major comment below and outline revisions to strengthen the manuscript while remaining faithful to the data collected.

read point-by-point responses

  1. Referee: [Findings / Implications] Findings and Implications sections: The claim that observed strategies reflect 'tensions between structural and sequence-focused reasoning' and 'multiple underlying models of program behavior' rests on an unvalidated interpretive mapping from static diagrams to internal cognitive models. The reported procedure (inductive coding of salient elements and issues on 55 diagrams) does not include think-aloud protocols, interviews, or member-checking that would distinguish representational choices from pre-existing models of program behavior.

    Authors: We agree that the mapping from observed diagram features to claims about internal cognitive models is interpretive rather than directly validated. The study was designed as a descriptive analysis of external representations produced in a time-constrained lab task, and the patterns (e.g., mixed notations, sequencing vs. hierarchy) are grounded in the artifacts themselves. However, we acknowledge that stronger assertions about 'underlying models' would benefit from additional data sources. We will revise the Findings and Implications sections to present these as observed tensions in representational strategies and hypothesized links to program-behavior models, while adding an explicit limitations paragraph noting the absence of think-aloud or interview validation. This preserves the descriptive contribution without overstating the cognitive inferences. revision: partial

  2. Referee: [Method] Method section: The description of the inductive thematic analysis supplies only high-level information on coding of salient elements and issues. Specific coding criteria, decision rules for distinguishing problem-specific misunderstandings from general issues, and the precise process for negotiated agreement are not reported, which bears on the reliability of the thematic categories that support the central claim.

    Authors: We accept this critique. The current Method section provides only a high-level overview of the inductive process and negotiated agreement. We will expand it with concrete details: (1) the initial codebook development, (2) explicit decision rules and examples for distinguishing problem-specific misunderstandings (e.g., incorrect word-game logic) from general decomposition issues (e.g., notation conflicts), and (3) the exact negotiated-agreement protocol, including how the two coders resolved disagreements and the final agreement rate. These additions will be placed in the main text or a supplementary appendix to allow readers to assess category reliability. revision: yes

standing simulated objections not resolved
  • The study did not collect think-aloud protocols, interviews, or member-checking data; therefore we cannot retroactively validate the mapping from diagrams to internal cognitive models without conducting new data collection.

Circularity Check

0 steps flagged

No circularity: empirical qualitative analysis of student artifacts

full rationale

This paper reports an inductive thematic analysis of 55 pencil-and-paper decomposition diagrams produced by novices in a single 50-minute task. The method codes salient elements and issues directly from the artifacts with negotiated agreement; no equations, fitted parameters, model predictions, or load-bearing self-citations appear. All claims (representational strategies, issues in notation/abstraction, tensions between structural and sequence-focused reasoning) are presented as observations from the coded data rather than derivations that reduce to inputs by construction. The study is therefore self-contained against external benchmarks with no circular steps.

Axiom & Free-Parameter Ledger

0 free parameters · 2 axioms · 0 invented entities

The study rests on standard qualitative education-research assumptions rather than mathematical axioms or fitted parameters.

axioms (2)
  • domain assumption Student pencil-and-paper diagrams are valid proxies for their internal decomposition models
    The analysis treats the diagrams as direct representations of how students plan solutions.
  • domain assumption Thematic analysis with negotiated agreement produces reliable characterizations of issues
    The method section relies on this standard practice in qualitative CS education research.

pith-pipeline@v0.9.1-grok · 5792 in / 1265 out tokens · 36138 ms · 2026-06-30T19:52:52.016089+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

60 extracted references · 4 canonical work pages

  1. [1]

    Shaaron Ainsworth. 1999. The functions of multiple representations.Computers & education33, 2-3 (1999), 131–152

    1999

  2. [2]

    Shaaron Ainsworth. 2006. DeFT: A conceptual framework for considering learning with multiple representations.Learning and instruction16, 3 (2006), 183–198

    2006

  3. [3]

    Valerie Barr and Chris Stephenson. 2011. Bringing computational thinking to K-12: What is involved and what is the role of the computer science education community?ACM inroads2, 1 (2011), 48–54

    2011

  4. [4]

    Joseph Bergin. 2000. Why procedural is the wrong first paradigm if OOP is the goal.URL: http://csis. pace. edu/ bergin/papers/Whynotproceduralfirst. html(2000)

    2000

  5. [5]

    Alan F Blackwell, Kirsten N Whitley, Judith Good, and Marian Petre. 2001. Cognitive factors in programming with diagrams.Artificial Intelligence Review15, 1 (2001), 95–114

    2001

  6. [6]

    Virginia Braun and Victoria Clarke. 2006. Using thematic analysis in psychology.Qualitative research in psychology3, 2 (2006), 77–101

    2006

  7. [7]

    Virginia Braun and Victoria Clarke. 2019. Reflecting on reflexive thematic analysis.Qualitative research in sport, exercise and health11, 4 (2019), 589–597

    2019

  8. [8]

    Virginia Braun and Victoria Clarke. 2021. To saturate or not to saturate? Questioning data saturation as a useful concept for thematic analysis and sample-size rationales.Qualitative research in sport, exercise and health13, 2 (2021), 201–216

    2021

  9. [9]

    John L Campbell, Charles Quincy, Jordan Osserman, and Ove K Pedersen. 2013. Coding in-depth semistructured interviews: Problems of unitization and intercoder reliability and agreement.Sociological methods & research42, 3 (2013), 294–320

    2013

  10. [10]

    Richard Catrambone. 1998. The subgoal learning model: Creating better examples so that students can solve novel problems.Journal of experimental psychology: General127, 4 (1998), 355

    1998

  11. [11]

    Mauro Cherubini, Gina Venolia, Rob DeLine, and Amy J Ko. 2007. Let’s go to the whiteboard: how and why software developers use drawings. In Proceedings of the SIGCHI conference on Human factors in computing systems. 557–566

    2007

  12. [12]

    Michelene TH Chi, Stephanie A Siler, Heisawn Jeong, Takashi Yamauchi, and Robert G Hausmann. 2001. Learning from human tutoring.Cognitive science25, 4 (2001), 471–533

    2001

  13. [13]

    Albert T Corbett and John R Anderson. 1995. Knowledge decomposition and subgoal reification in the ACT programming tutor. (1995)

    1995

  14. [14]

    Kathryn Cunningham, Sarah Blanchard, Barbara Ericson, and Mark Guzdial. 2017. Using tracing and sketching to solve programming problems: Replicating and extending an analysis of what students draw. InProceedings of the 2017 ACM Conference on international computing education research. 164–172

    2017

  15. [15]

    Michael De Raadt, Richard Watson, and Mark Toleman. 2009. Teaching and assessing programming strategies explicitly. InProceedings of the Eleventh Australasian Conference on Computing Education, Vol. 95. 45–54

    2009

  16. [16]

    Alan Dix and Layda Gongora. 2011. Externalisation and design. InProcedings of the second conference on creativity and innovation in design. 31–42

    2011

  17. [17]

    Benedict Du Boulay, Tim O’Shea, and John Monk. 1981. The black box inside the glass box: presenting computing concepts to novices.International Journal of man-machine studies14, 3 (1981), 237–249. Manuscript submitted to ACM Planning on Paper: Problem Decomposition with Diagrams in Introductory Computing 21

    1981

  18. [18]

    2018.How to design programs: an introduction to programming and computing

    Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, and Shriram Krishnamurthi. 2018.How to design programs: an introduction to programming and computing. MIT Press

    2018

  19. [19]

    Sally Fincher, Johan Jeuring, Craig S Miller, Peter Donaldson, Benedict Du Boulay, Matthias Hauswirth, Arto Hellas, Felienne Hermans, Colleen Lewis, Andreas Mühling, et al. 2020. Notional machines in computing education: The education of attention. InProceedings of the working group reports on innovation and technology in computer science education. 21–50

    2020

  20. [20]

    Kathi Fisler, Shriram Krishnamurthi, and Janet Siegmund. 2016. Modernizing plan-composition studies. InProceedings of the 47th ACM Technical Symposium on Computing Science Education. 211–216

    2016

  21. [21]

    David Grove, Greg DeFouw, Jeffrey Dean, and Craig Chambers. 1997. Call graph construction in object-oriented languages. InProceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications. 108–124

    1997

  22. [22]

    Georgiana Haldeman, Peter Ohmann, and Paul Denny. 2026. Systematically Thinking about the Complexity of Code Structuring Exercises at Introductory Level. InProceedings of the 57th ACM Technical Symposium on Computer Science Education V. 1. 442–448

    2026

  23. [23]

    David Hammer and Leema K Berland. 2014. Confusing claims for data: A critique of common practices for presenting qualitative research on learning.Journal of the Learning Sciences23, 1 (2014), 37–46

    2014

  24. [24]

    David G Hendry. 2006. Sketching with Conceptual Metaphors to Explain Computational Processes. In2006 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). 95–102

    2006

  25. [25]

    Jones, Helen Ross, Timothy Lynam, Pascal Perez, and Anne Leitch

    Natalie A. Jones, Helen Ross, Timothy Lynam, Pascal Perez, and Anne Leitch. 2011. Mental Models: An Interdisciplinary Synthesis of Theory and Methods.Ecology and Society16, 1 (2011)

    2011

  26. [26]

    Thomas D LaToza and Brad A Myers. 2011. Visualizing call graphs. In2011 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). 117–124

    2011

  27. [27]

    Marcia C Linn and John Dalbey. 1985. Cognitive consequences of programming instruction: Instruction, access, and ability.Educational Psychologist 20, 4 (1985), 191–206

    1985

  28. [28]

    Raymond Lister, Elizabeth S Adams, Sue Fitzgerald, William Fone, John Hamer, Morten Lindholm, Robert McCartney, Jan Erik Moström, Kate Sanders, Otto Seppälä, et al. 2004. A multi-national study of reading and tracing skills in novice programmers.ACM SIGCSE bulletin36, 4 (2004), 119–150

    2004

  29. [29]

    Dastyni Loksa, Amy J Ko, Will Jernigan, Alannah Oleson, Christopher J Mendez, and Margaret M Burnett. 2016. Programming, problem solving, and self-awareness: Effects of explicit guidance. InProceedings of the 2016 CHI conference on human factors in computing systems. 1449–1461

    2016

  30. [30]

    Richard E Mayer. 2002. Multimedia learning. InPsychology of learning and motivation. Vol. 41. Elsevier, 85–139

    2002

  31. [31]

    Orna Muller, David Ginat, and Bruria Haberman. 2007. Pattern-oriented instruction and its influence on problem decomposition and solution construction. InProceedings of the 12th annual SIGCSE conference on Innovation and technology in computer science education. 151–155

    2007

  32. [32]

    1972.Human problem solving

    Allen Newell, Herbert Alexander Simon, et al. 1972.Human problem solving. Vol. 104. Prentice-hall Englewood Cliffs, NJ

    1972

  33. [33]

    Aadarsh Padiyath and Tamara Nelson-Fromm. 2026. Reflecting on Thematic Analysis in Computer Science Education Research: A Field Guide for Researchers and Reviewers. InProceedings of the 57th ACM Technical Symposium on Computer Science Education V. 1. 790–796

    2026

  34. [34]

    David Lorge Parnas. 1972. On the criteria to be used in decomposing systems into modules.Commun. ACM15, 12 (1972), 1053–1058

    1972

  35. [35]

    Nancy Pennington. 1987. Stimulus structures and mental representations in expert comprehension of computer programs.Cognitive psychology19, 3 (1987), 295–341

    1987

  36. [36]

    2024.Learn AI-assisted Python programming: with github copilot and ChatGPT

    Leo Porter and Daniel Zingaro. 2024.Learn AI-assisted Python programming: with github copilot and ChatGPT. Manning

    2024

  37. [37]

    In2024 Working Group Reports on Innovation and Technology in Computer Science Education(Milan, Italy)(ITiCSE 2024)

    James Prather, Juho Leinonen, Natalie Kiesler, Jamie Gorson Benario, Sam Lau, Stephen MacNeil, Narges Norouzi, Simone Opel, Vee Pettit, Leo Porter, Brent N. Reeves, Jaromir Savelka, David H. Smith IV, Sven Strickroth, and Daniel Zingaro. 2025. Beyond the Hype: A Comprehensive Review of Current Trends in Generative AI Research, Teaching Practices, and Tool...

    work page doi:10.1145/3689187.3709614 2025

  38. [38]

    Peter J Rich, Garrett Egan, and Jordan Ellsworth. 2019. A framework for decomposition in computational thinking. InProceedings of the 2019 ACM conference on innovation and technology in computer science education. 416–421

    2019

  39. [39]

    Robert S Rist. 1989. Schema creation in programming.Cognitive science13, 3 (1989), 389–414

    1989

  40. [40]

    Robert S Rist. 1991. Knowledge creation and retrieval in program design: A comparison of novice and intermediate student programmers. Human-Computer Interaction6, 1 (1991), 1–46

    1991

  41. [41]

    Elijah Rivera, Kathi Fisler, and Shriram Krishnamurthi. 2024. Observations on the Design of Program Planning Notations for Students. InProceedings of the 55th ACM Technical Symposium on Computer Science Education V. 1. 1133–1139

    2024

  42. [42]

    Elijah Rivera, Shriram Krishnamurthi, and Robert Goldstone. 2022. Plan composition using higher-order functions. InProceedings of the 2022 ACM Conference on International Computing Education Research-Volume 1. 84–104

    2022

  43. [43]

    Anthony Robins, Janet Rountree, and Nathan Rountree. 2003. Learning and Teaching Programming: A Review and Discussion.Computer Science Education13, 2 (2003), 137–172

    2003

  44. [44]

    Jorma Sajaniemi and Marja Kuittinen. 2008. From procedures to objects: A research agenda for the psychology of object-oriented programming education.Human technology4, 1 (2008), 75–91

    2008

  45. [45]

    Mario Luis Small. 2009. How many cases do I need?’ On science and the logic of case selection in field-based research.Ethnography10, 1 (2009), 5–38

    2009

  46. [46]

    Elliot Soloway. 1986. Learning to program = learning to construct mechanisms and explanations.Commun. ACM29, 9 (1986), 850–858. Manuscript submitted to ACM 22 Vadaparty et al

    1986

  47. [47]

    Ting Song and Kurt Becker. 2014. Expert vs. novice: Problem decomposition/recomposition in engineering design. In2014 International Conference on interactive collaborative learning (ICL). IEEE, 181–190

    2014

  48. [48]

    Ting Song, Kurt Becker, John Gero, Scott DeBerard, Oenardi DeBerard, and Edward Reeve. 2016. Problem Decomposition and Recomposition in Engineering Design: A Comparison of Design Behavior between Professional Engineers, Engineering Seniors, and Engineering Freshmen.Journal of Technology Education27, 2 (2016), 37–56

    2016

  49. [49]

    Juha Sorva. 2013. Notional machines and introductory programming education.ACM Trans. Comput. Educ.13, 2, Article 8 (2013), 31 pages. https://doi.org/10.1145/2483710.2483713

    work page doi:10.1145/2483710.2483713 2013

  50. [50]

    James C Spohrer and Elliot Soloway. 1986. Novice mistakes: Are the folk wisdoms correct?Commun. ACM29, 7 (1986), 624–632

    1986

  51. [51]

    Stevens, Glenford J

    Wayne P. Stevens, Glenford J. Myers, and Larry L. Constantine. 1974. Structured design.IBM Syst. J.13, 2 (June 1974), 115–139

    1974

  52. [52]

    Physics of Notations

    Harald Störrle and Andrew Fish. 2013. Towards an Operationalization of the “Physics of Notations” for the Analysis of Visual Languages. In International Conference on Model Driven Engineering Languages and Systems. Springer, 104–120

    2013

  53. [53]

    Barbara Tversky. 2011. Visualizing thought. Topics in Cognitive Science, 3 (3), 499–535

    2011

  54. [54]

    Jacqueline Whalley, Christine Prasad, and PK Ajith Kumar. 2007. Decoding doodles: novice programmers and their annotations. InACM International Conference Proceeding Series, Vol. 239. 171–178

    2007

  55. [55]

    Lee J White. 1987. Software testing and verification. InAdvances in computers. Vol. 26. Elsevier, 335–391

    1987

  56. [56]

    Katy Williams, Alex Bigelow, and Katherine E. Isaacs. 2023. Data Abstraction Elephants: The Initial Diversity of Data Representations and Mental Models. InProceedings of the 2023 CHI Conference on Human Factors in Computing Systems(Hamburg, Germany)(CHI ’23). Association for Computing Machinery, New York, NY, USA, Article 803, 24 pages. doi:10.1145/354454...

    work page doi:10.1145/3544548.3580669 2023

  57. [57]

    Jeannette M Wing. 2006. Computational thinking.Commun. ACM49, 3 (2006), 33–35

    2006

  58. [58]

    Titus Winters. 2026. CS and SE Education, Post-AI. InProceedings of the 57th ACM Technical Symposium on Computer Science Education V. 1. 2–2

    2026

  59. [59]

    Jingyue Zhang, J. D. Zamfirescu-Pereira, Elena L. Glassman, Damien Masson, and Ian Arawjo. 2026. How Notations Evolve: A Historical Analysis with Implications for Supporting User-Defined Abstractions. arXiv:2602.01525 [cs.HC] https://arxiv.org/abs/2602.01525

    work page arXiv 2026

  60. [60]

    Hong Zhu. 1995. Axiomatic assessment of control flow-based software test adequacy criteria.Software Engineering Journal10, 5 (1995), 194–204. Received 27 February 2026; revised 1 May 2026; accepted 12 May 2026 Manuscript submitted to ACM

    1995