Software Engineering · arXiv:2611.16293 v1 · submitted 12 Nov 2026 · 32 references
Rasoi: Visual Diffs for Evaluating Structural Changes Made by Coding Agents
The paper says
“Coding agents let developers modify software rapidly through natural language. However, as agents take on larger changes, developers can lose track of how the codebase is evolving.”
more of the abstract
These edits may look correct on the surface while restructuring the system in unexpected ways: duplicating logic, changing modules outside the requested scope, removing functionality developers meant to keep, or introducing architectural drift. We investigate how visual diffs can help developers understand and evaluate the structural changes that coding agents make. We present Rasoi, a design probe that maps how a codebase's architecture evolves after each agent-made edit, letting developers inspect which architectural elements and relationships were added, modified, or removed across multiple levels of abstraction. We deployed Rasoi in a week-long study with 12 developers working on their own codebases across varied technical domains. We found that visual diffs helped developers see whether changes stayed within scope, notice unexpected restructuring, and understand how modified parts related to the system as a whole. Our findings suggest that the value of oversight tools for coding agents lies less in making developers trust the agent and more in helping developers feel confident in their own evaluation of agent-made changes. We discuss implications for visual tools that support code comprehension and human oversight in AI-assisted software development.
from the abstract
Pith says
Machine review · deepseek-v4-flash · 13 Nov 2026 · what was read was not recorded · not checked by a person
It can be wrong. Challenge this review or reply to it.
Holds up. Solid design probe study that does what it says on the tin. The central finding—that visual diffs help developers evaluate agent-made structural changes—is well-supported by qualitative evidence. The paper is honest about its limitations and doesn't overclaim. Worth engaging with. This line is wrong
1 major objection · 6 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the 32 references say.
The paper says, at Appendix A and Section V-A2
The review did not quote this passage.
Pith says: Objection 1 of 1 · major
Rasoi's diffs are computed between C4 snapshots that the coding agent itself generates from the codebase (Appendix A: the agent is instructed to produce diagram.json files from the code after each edit). The validator checks schema conformance, not whether the snapshot accurately reflects the true architecture or the true set of edits.
more of objection 1
The central finding in Section V-A2 ("visual diffs surfaced unexpected side effects and regressions") inherits this dependence: if the agent's own structural analysis omits, misattributes, or fabricates changes, the diff will be systematically wrong and a participant who "realized" something from the diagram could be reacting to an artifact of the agent's self-report rather than to the code. The paper does not acknowledge this ground-truth dependence anywhere, and it is distinct from the acknowledged C4-limitation in Section VII (abstraction fit). I ask the authors to (a) state this dependence explicitly in the limitations, and (b) report whatever evidence exists that snapshots faithfully represented the codebases, for example any spot-checks of generated snapshots against the actual diffed files, or at minimum a statement that no such checks were performed and a corresponding softening of the language in Section V-A2.
6 minor objections
The paper says, at Section IV
Pith says: minor objection 1 of 6
The post-study survey is referenced throughout the findings (Fig. 4, Fig. 5) and in the analysis paragraph, but it is not listed among the three data-collection forms in the Procedure subsection, and its items, scale, and administration timing are never described. Please add a short description of the survey to the data-collection section.
The paper says, at Figures 2 and 3
Pith says: minor objection 2 of 6
The interface and abstraction-level figures are referenced by caption elements (A–F) that cannot be inspected in the manuscript text as provided; please confirm the figures are rendered at legible resolution in the final version so the walkthrough in Section III-B can be checked against them.
show 4 more
The paper says, at Section V-A2 and Section V-B2
Pith says: minor objection 3 of 6
The claims that "developers wanted semantically meaningful details, not just more details" and that participants' use clustered cleanly into the reported use cases rest on a small number of participants (P1, P2, P3 for the detail claim). A sentence noting which claims are supported by a single participant would strengthen the reporting without changing the findings.
The paper says, at References
Pith says: minor objection 4 of 6
Reference [5] for UML is an industry blog URL (Miro); consider citing a canonical source (e.g., ISO/IEC 19505 or a standard UML reference) instead of or in addition to the web page.
The paper says, at Section V-A2
Pith says: minor objection 5 of 6
The quoted participant reaction "what the ...," appears to be a redacted expletive; please bracket it (e.g., "what the [expletive]") so the quote reads as a deliberate elision rather than a typographical artifact.
The paper says, at Section VIII
Pith says: minor objection 6 of 6
In the conclusion, "strengthened participants' confidence... more consistently 10 than it increased trust" contains a stray "10" that appears to be a layout artifact from the previous line; please remove it.
What would settle it
A controlled experiment comparing Rasoi's visual diffs against file-level diffs and agent-generated summaries for a common task would test whether the architecture-level visualization provides incremental value beyond existing tools. The authors already call for this in their limitations (Section VII).
from the skeptic's reading
How the review went
4 readings by deepseek-v4-flash · 13 Nov 2026
- Reader holds up
- Skeptic agrees
- Editor wrote the verdict above
- Referee minor revision: 1 major objection, 6 minor
Not run on this paper: the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The review in brief, machine-written
Rasoi is a well-scoped design probe study that makes a modest but solid contribution. The paper applies known techniques (C4 architecture views, versioned diffs) to a relatively new problem: evaluating structural changes made by coding agents. The central claim—that visual diffs help developers verify whether agent-made changes stayed within scope, surface unexpected side effects, and understand how modified parts relate to the rest of the system—is supported by qualitative evidence from a week-long deployment with 12 participants working on their own codebases. The findings are plausible and the paper does not overclaim.
The study is well-designed for a probe: 12 participants, week-long deployment on their own codebases, daily check-ins, post-study interviews, and survey data. The findings are supported by participant quotes and Likert responses. The authors are transparent about limitations: small sample, uncontrolled deployment, probe-stage tool, and the C4 model's occasional mismatch. The weakest assumption identified by the reader (that C4 is a suitable abstraction) is acknowledged by the authors themselves in Section VII.
Soft spots: The study is uncontrolled (no comparison to file-level diffs or agent summaries), so we can't isolate the contribution of architecture views vs. versioned diffs vs. drill-down interaction. The sample is small and homogeneous (experienced developers who regularly use coding agents). The C4 model is sometimes too heavy for small projects and too generic for specialized tasks, as the authors note. These are real limitations, but the paper acknowledges them and doesn't claim more than the evidence supports.
Who this is for: Researchers in human-AI interaction for programming, software visualization, and program comprehension. Practitioners building oversight tools for coding agents. The paper deserves a serious referee; it's a clean study that makes a clear, modest claim and supports it with appropriate evidence. I'd accept it for a venue like CHI or UIST with minor revisions.
Recommendation: Accept with minor revisions. The paper is ready for peer review.
The strongest objection
The paper is a well-scoped design probe study that makes a modest but solid contribution. The central claim—that visual diffs of codebase architecture help developers evaluate structural changes made by coding agents—is supported by qualitative evidence from a week-long deployment with 12 participants working on their own codebases. The authors are transparent about limitations: small sample, uncontrolled deployment, probe-stage tool, and the C4 model's occasional mismatch. The weakest assumption identified by the reader (that C4 is a suitable abstraction) is acknowledged by the authors themselves in Section VII. The findings are plausible and the paper does not overclaim. I see no load-bearing concern that would undermine the central argument within the scope the paper sets for itself.
The reader's verdict is ACCEPT with high confidence, and the weakest assumption identified (C4 model suitability) is explicitly acknowledged by the authors. My stress-test pass finds no additional load-bearing concern. The paper is honest about its scope and limitations, the qualitative evidence is appropriately interpreted, and the central claim is modest enough to be supported by the study design. The only potential concern—that the study cannot isolate Rasoi's value from alternatives—is already stated by the authors as a limitation. No adjustment to the verdict is warranted.
The referee's report
If the findings hold, the contribution is timely and useful: it identifies a concrete failure mode of agent-assisted development (loss of structural awareness) and proposes a lightweight, inspectable remedy that is plausible and, importantly, is evaluated through a naturalistic week-long deployment on participants' real codebases rather than a scripted lab task. The study is honestly scoped: the authors state plainly that Rasoi is a probe rather than a finished tool, that the uncontrolled deployment cannot isolate Rasoi's value from alternatives such as file-level diffs or agent summaries (Section VII), and that the C4 abstraction is sometimes too heavy or too generic. The claims are calibrated to the evidence—participant quotes support each reported use case, and survey counts triangulate the qualitative themes. The paper makes no mathematical or predictive claims, so there is no circularity burden; its value is as a well-reasoned, falsifiable design hypothesis (support at evaluation moments, semantic rather than merely denser detail) that later controlled studies can test. My only substantive concern is a ground-truth question about the mechanism itself, described below.
Pith's reading of the paper (a machine's summary, not the authors')
The paper presents Rasoi, a design probe that generates versioned architecture maps and visual diffs of a codebase after each edit by a coding agent. In a week-long study with 12 developers working on their own projects, the authors found that these visual diffs helped developers verify whether agent-made changes stayed within intended scope, surface unexpected side effects and regressions, and understand how modified parts related to the rest of the system. The key finding is that the primary value of such oversight tools is not in making developers trust the agent more, but in helping them feel confident in their own evaluation of agent-made changes. The paper argues that visual support for agent-assisted development should appear at moments of evaluation rather than continuously, and should provide semantic detail matched to the developer's current question.
What carries the argument. The central mechanism is the versioned architecture map generated using the C4 model (context, containers, components, code). After each agent edit, Rasoi produces a new architecture snapshot and computes a visual diff against the previous version, color-coding nodes and edges as added, modified, or removed. This allows developers to inspect structural change across multiple levels of abstraction, from broad system context down to component-level detail, with a minimap to maintain orientation. The C4 model provides a repeatable scaffold that can be regenerated after each agent edit and compared across versions, which is essential for making structural change visible over time.
Core claim. The paper establishes that visual diffs of codebase architecture, generated by the Rasoi probe, help developers evaluate structural changes made by coding agents. The central discovery is that these visualizations support three distinct evaluation tasks: verifying that changes stayed within expected scope (e.g., P1 confirming an agent only touched command-handling code), surfacing unexpected side effects (e.g., P4 discovering an agent had removed an audio warning cue), and understanding how modified components relate to the larger system (e.g., P2 using the visualization to reason about dependencies during a Firebase-to-Supabase migration). The paper's most consequential finding is that Rasoi strengthened developers' confidence in their own understanding of the codebase (10 of 12 participants agreed) more consistently than it increased trust in the coding agent itself (only 2 of 12 agreed). This suggests that the role of oversight tools for coding agents is to support human judgment rather than to build trust in the AI.
The premise it rests on. The study assumes that the C4 model (context, containers, components, code) is a suitable and sufficient abstraction for representing codebase architecture across the diverse projects used by participants, but the paper acknowledges that C4 was sometimes too heavy for small projects and too generic for specialized tasks like tracing Firebase dependencies or following variables through scientific code.
If the paper is right (Pith's inferences, not the authors')
Oversight tools for coding agents should be designed for evaluation moments (after a meaningful change) rather than as continuous ambient displays, since developers in the study turned to Rasoi mainly after refactors, failed debugging attempts, or sequences of changes that made the codebase feel out of sync with their mental model.
Architectural visualizations can externalize tacit knowledge about codebase structure that is normally held by a few experts, making it accessible to collaborators and potentially to coding agents themselves as a source of design constraints.
Future visual support should provide semantically meaningful detail matched to the developer's current validation question (e.g., tracing Firebase dependencies during a migration, or following variable flow through scientific code) rather than simply adding more detail to the diagram.
The finding that visual diffs strengthened developers' confidence in their own understanding more than trust in the agent suggests that evaluation tools should prioritize supporting human judgment over building trust in the AI system.
The paper's results imply that the current practice of reviewing agent-made changes through file-level diffs or agent-generated summaries may be insufficient for detecting architectural drift, since participants repeatedly discovered unexpected structural changes only through the architecture-level visual diff.
If architectural visualizations can externalize tacit knowledge about design rationale (as the paper suggests), they could serve as a bridge between human experts and coding agents, allowing developers to annotate structural constraints that future agent edits should respect.
The finding that Rasoi was most useful at specific evaluation moments suggests a design pattern for agent-assisted coding tools: provide lightweight, on-demand structural overviews rather than persistent dashboards, and trigger them when the agent completes a change that crosses a complexity threshold.
Check this review
Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.
How often reviews like this one are right
Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.
How often objections from reviews like this one are right: not yet measured
Reviews by people
This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.
The paper
Abstract
Coding agents let developers modify software rapidly through natural language. However, as agents take on larger changes, developers can lose track of how the codebase is evolving. These edits may look correct on the surface while restructuring the system in unexpected ways: duplicating logic, changing modules outside the requested scope, removing functionality developers meant to keep, or introducing architectural drift. We investigate how visual diffs can help developers understand and evaluate the structural changes that coding agents make. We present Rasoi, a design probe that maps how a codebase's architecture evolves after each agent-made edit, letting developers inspect which architectural elements and relationships were added, modified, or removed across multiple levels of abstraction. We deployed Rasoi in a week-long study with 12 developers working on their own codebases across varied technical domains. We found that visual diffs helped developers see whether changes stayed within scope, notice unexpected restructuring, and understand how modified parts related to the system as a whole. Our findings suggest that the value of oversight tools for coding agents lies less in making developers trust the agent and more in helping developers feel confident in their own evaluation of agent-made changes. We discuss implications for visual tools that support code comprehension and human oversight in AI-assisted software development.
The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.
abstract compiled · 2026-11-13
The authors' main claim, as the classifier picked it out 0.98
“Our findings suggest that the value of oversight tools for coding agents lies less in making developers trust the agent and more in helping developers feel confident in their own evaluation of agent-made changes.”
How the main claim is stated: hedged possibility 1.00
What the abstract itself states, as probabilities: claims first 0.04 · states limitation 0.22 · human participants 0.98 · controlled comparison 0.07 · randomized assignment 0.02 · states quantitative result 0.81 · compares with prior results 0.07 · mentions code or data availability 0.03
The abstract, sentence by sentence
This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.
| Sentence | Role | The authors' own work | States the main conclusion | Strength |
|---|---|---|---|---|
| Coding agents let developers modify software rapidly through natural language. | background 1.00 | 0.04 | 0.01 | asserted 1.00 |
| However, as agents take on larger changes, developers can lose track of how the codebase is evolving. | background 0.93 | 0.05 | 0.02 | hedged possibility 0.62 |
| These edits may look correct on the surface while restructuring the system in unexpected ways: duplicating logic, changing modules outside the requested scope, removing functionality developers meant to keep, or introducing architectural drift. | background 0.96 | 0.05 | 0.02 | hedged possibility 0.99 |
| We investigate how visual diffs can help developers understand and evaluate the structural changes that coding agents make. | contribution 0.84 | 0.58 | 0.03 | unclear 0.42 |
| We present Rasoi, a design probe that maps how a codebase's architecture evolves after each agent-made edit, letting developers inspect which architectural elements and relationships were added, modified, or removed across multiple levels of abstraction. | contribution 0.87 | 0.92 | 0.05 | asserted 1.00 |
| We deployed Rasoi in a week-long study with 12 developers working on their own codebases across varied technical domains. | method 0.93 | 0.96 | 0.02 | asserted 1.00 |
| We found that visual diffs helped developers see whether changes stayed within scope, notice unexpected restructuring, and understand how modified parts related to the system as a whole. | result 1.00 | 0.97 | 0.27 | asserted 1.00 |
| Our findings suggest that the value of oversight tools for coding agents lies less in making developers trust the agent and more in helping developers feel confident in their own evaluation of agent-made changes. | interpretation 1.00 | 0.90 | 0.82 | hedged possibility 1.00 |
| We discuss implications for visual tools that support code comprehension and human oversight in AI-assisted software development. | future work 0.69 | 0.41 | 0.04 | unclear 0.98 |
What kind of paper the classifier reports this is: method or tool 0.86 · evidence from observation or experiment 1.00
What was examined, and what was not
Sources read
- arXiv listing abstract v1
Not examined
- full text
- figures and tables
- references and citing sentences
- relations to other papers
Levels run
- P abstract
Not run
- S sections
- T body sentences
- C citations
- R cross-paper relations
How the labels were made
Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-11-13: 1 request, 6,845 input tokens.
Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON
Figures (6)
Figures are the authors', reproduced from the paper.
References (32)
- [1] “Claude code,” https://claude.com/product/claude-code, 2026, accessed 2026-05-12 on Pith
- [2] “Cursor,” https://cursor.com/home, 2026, accessed 2026-05-12 on Pith
- [3] “OpenAI codex,” https://openai.com/codex/, 2026, accessed 2026-05-12 on Pith
- [4] F. P. Brooks, “No silver bullet: Essence and accidents of software engineering,”Computer, vol. 20, no. 4, pp. 10–19, 1987 on Pith
- [5] “The ultimate guide to UML diagrams,” https://miro.com/diagramming/ what-is-a-uml-diagram/, 2024, accessed 2026-05-12 on Pith
- [6] P. Kruchten, “Architectural blueprints: The “4+1” view model of soft- ware architecture,”IEEE Software, vol. 12, no. 6, pp. 42–50, 1995 on Pith
- [7] P. Clements, F. Bachmann, L. Bass, D. Garlan, J. Ivers, R. Little, R. Nord, and J. Stafford,Documenting Software Architectures: Views and Beyond. Addison-Wesley Professional, 2002 on Pith
- [8] S. Brown, “The C4 model for visualising software architecture,” https: //c4model.com/, 2018, accessed 2026-05-10 on Pith
- [9] A. Shahbazian, Y . K. Lee, D. Le, and N. Medvidovic, “Uncovering architectural design decisions,” 2017 on Pith
- [10] ISO/IEC/IEEE, “ISO/IEC/IEEE 42010:2022 systems and software engi- neering — architecture description,” 2022, international Standard on Pith
- [11] A. Heinonen, B. Lehtel ¨a, A. Hellas, and F. Fagerholm, “Synthesizing re- search on programmers’ mental models of programs, tasks and concepts: A systematic literature review,”Information and Software Technology, vol. 164, p. 107300, 2023 on Pith
- [12] J. Sillito, G. C. Murphy, and K. De V older, “Asking and answering questions during a programming change task,”IEEE Transactions on Software Engineering, vol. 34, no. 4, pp. 434–451, 2008 on Pith
- [13] ——, “Questions programmers ask during software evolution tasks,” inProceedings of the 14th ACM SIGSOFT International Symposium on Foundations of Software Engineering, ser. SIGSOFT ’06/FSE-14. Association for Computing Machinery, 2006, pp. 23–34 on Pith
- [14] G. C. Murphy, D. Notkin, and K. J. Sullivan, “Software reflexion models: Bridging the gap between source and high-level models,” inProceedings of the 3rd ACM SIGSOFT Symposium on Foundations of Software Engineering, ser. SIGSOFT ’95. Association for Computing Machinery, 1995, ... on Pith
- [15] ——, “Software reflexion models: Bridging the gap between design and implementation,”IEEE Transactions on Software Engineering, vol. 27, no. 4, pp. 364–380, 2001 on Pith
- [16] B. de Alwis and G. C. Murphy, “Using visual momentum to explain disorientation in the Eclipse IDE,” inProceedings of the 2006 IEEE Symposium on Visual Languages and Human-Centric Computing, ser. VL/HCC ’06. IEEE, 2006, pp. 51–54 on Pith
- [17] A. Bragdon, S. P. Reiss, R. Zeleznik, S. Karumuri, W. Cheung, J. Kaplan, C. Coleman, F. Adeputra, and J. J. LaViola, “Code bubbles: Rethinking the user interface paradigm of integrated development environments,” inProceedings of the 32nd ACM/IEEE International Conference on So... on Pith
- [18] M. Adeli, N. Nelson, S. Chattopadhyay, H. Coffey, A. Z. Henley, and A. Sarma, “Supporting code comprehension via annotations: Right information at the right time and place,” inProceedings of the 2020 IEEE Symposium on Visual Languages and Human-Centric Computing, ser. VL/HCC ’... on Pith
- [19] H. Mozannar, G. Bansal, A. Fourney, and E. Horvitz, “Reading between the lines: Modeling user behavior and costs in AI-assisted program- ming,” inProceedings of the CHI Conference on Human Factors in Computing Systems, ser. CHI ’24. Association for Computing Machinery, 2024 on Pith
- [20] J. T. Liang, C. Yang, and B. A. Myers, “A large-scale survey on the usability of AI programming assistants: Successes and challenges,” inProceedings of the 46th IEEE/ACM International Conference on Software Engineering, ser. ICSE ’24. Association for Computing Machinery, 2024 on Pith
show 12 more
- [21] N. Tang, M. Chen, Z. Ning, A. Bansal, Y . Huang, C. McMillan, and T. J.- J. Li, “Developer behaviors in validating and repairing LLM-generated code using IDE and eye tracking,” inProceedings of the 2024 IEEE Symposium on Visual Languages and Human-Centric Computing, ser. VL/HC... on Pith
- [22] S. I. Ross, F. Martinez, S. Houde, M. Muller, and J. D. Weisz, “The programmer’s assistant: Conversational interaction with a large language model for software development,” inProceedings of the 28th International Conference on Intelligent User Interfaces, ser. IUI ’23. Associ... on Pith
- [23] A. Sergeyuk, Y . Golubev, T. Bryksin, and I. Ahmed, “Using AI-based coding assistants in practice: State of affairs, perceptions, and ways forward,”Information and Software Technology, vol. 178, p. 107610, 2025 on Pith
- [24] G. Desolda, A. Esposito, F. Greco, C. Tucci, P. Buono, and A. Piccinno, “Understanding user mental models in AI-driven code completion tools: Insights from an elicitation study,”International Journal of Human- Computer Studies, vol. 205, p. 103648, 2025 on Pith
- [25] J. D. Zamfirescu-Pereira, E. Jun, M. Terry, Q. Yang, and B. Hartmann, “Beyond code generation: LLM-supported exploration of the program design space,” inProceedings of the CHI Conference on Human Factors in Computing Systems, ser. CHI ’25. Association for Computing Machinery, 2025 on Pith
- [26] R. Cheng, T. Barik, A. Leung, F. Hohman, and J. Nichols, “BISCUIT: Scaffolding LLM-generated code with ephemeral UIs in computational notebooks,” inProceedings of the 2024 IEEE Symposium on Visual Languages and Human-Centric Computing, ser. VL/HCC ’24. IEEE, 2024, pp. 13–23 on Pith
- [27] L. Yan, A. Hwang, Z. Wu, and A. Head, “Ivie: Lightweight an- chored explanations of just-generated code,” inProceedings of the CHI Conference on Human Factors in Computing Systems, ser. CHI ’24. Association for Computing Machinery, 2024 on Pith
- [28] Y . Kim, K. Jang, H. Song, M. Shin, and B. Suh, “CodeV oyager: Integrating interactive visual aids with LLMs for code comprehension,” inProceedings of the 31st International Conference on Intelligent User Interfaces, ser. IUI ’26. New York, NY , USA: Association for Computing ... on Pith
- [29] Y . Bajpai, B. Chopra, P. Biyani, C. Aslan, D. Coleman, S. Gulwani, C. Parnin, A. Radhakrishna, and G. L. Soares, “Let’s fix this together: Conversational debugging with GitHub Copilot,” inProceedings of the 2024 IEEE Symposium on Visual Languages and Human-Centric Computing, ... on Pith
- [30] R. Suzuki, G. Soares, A. Head, E. L. Glassman, R. Reis, M. Mongiovi, L. D’Antoni, and B. Hartmann, “TraceDiff: Debugging unexpected code behavior using trace divergences,” inProceedings of the 2017 IEEE Symposium on Visual Languages and Human-Centric Computing, ser. VL/HCC ’17... on Pith
- [31] L. Yan, J. Tao, L. B. Chilton, and A. Head, “Answering developer ques- tions with annotated agent-discovered program traces,” inProceedings of the 38th Annual ACM Symposium on User Interface Software and Technology, ser. UIST ’25. Association for Computing Machinery, 2025 on Pith
- [32] A. W. Lawrence, A. N. Badre, and J. T. Stasko, “Empirically evaluating the use of animations to teach algorithms,” inProceedings of the 1994 IEEE Symposium on Visual Languages, ser. VL ’94. IEEE, 1994, pp. 48–54. 13 on Pith
Challenges and discussion
Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.
Come back by email
A short list of the week's newly reviewed papers. Nothing is sent until you confirm from your inbox, and every email has a link that stops it. No account.
No comments yet.
Sign in to comment