Pith. sign in

REVIEW 3 major objections 4 minor 41 references

NoteFlow: Recommending Charts as Sight Glasses for Tracing Data Flow in Computational Notebooks

T0 review · 3 major / 4 minor · reviewed 2026-08-09 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read NoteFlow reconstructs a notebook's data flow as traced charts, letting analysts watch every table change and locate the exact code line behind an anomaly.

desk verdict The chart-tracing with column substitution is a genuinely new mechanism, but the paper's central claim rests on an unmeasured parser, and the user study alone cannot carry that weight. read the letter →

arxiv 2502.02326 v1 pith:4WTE6C63 submitted 2025-02-04 cs.HC

Yuan Tian , Dazhen Deng , Sen Yang , Huawei Zheng , Bowen Shi , Kai Xiong , Xinjing Yi , Yingcai Wu This is my paper · ORCID
classification cs.HC
keywords exploratorydataanalysisvisualizationrecommendationcomputationalnotebooksflowtracingchartassightglasspandastransformationnotebookdebuggingprovenance
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

NoteFlow is a notebook library that reconstructs the flow of pandas tables through cells and recommends charts as "sight glasses" so analysts can watch how each table's state evolves across the whole exploratory analysis, not just at one cell. The paper's central claim is that this combination of flow parsing, transformation-aware chart recommendation, and consistent chart tracing lets users locate the exact code line responsible for a data anomaly and understand an unfamiliar script with far less manual plotting than the status quo. In a comparative user study against a state-of-the-art recommendation widget, all twelve participants found the anomalous code line with NoteFlow, while users of the baseline often failed or had to fall back on manual Pandas work. If the claim holds, EDA in notebooks stops being a sequence of disconnected cell snapshots and becomes a traceable, view-consistent data lineage.

What carries the argument

The central object is the "sight glass": a recommended chart bound to a table snapshot and reused across the data-flow graph with automatic encoding substitution when columns appear or disappear. Carrying the argument is a three-module pipeline: flow parsing (an extension of the Comantics script-semantics method, adding support for chained operations and unassigned calls), rule-based chart recommendation driven by 12 transformation types and three data facts, and chart tracing with a stepped layout that preserves prior states when cells are re-run. The encoding-substitution step is what makes consistent tracing possible when columns are added or deleted.

What would settle it

A concrete test would be to run NoteFlow on a corpus of real notebooks containing chained pandas calls (for example groupby–agg–reset_index), user-defined transformation functions, and cell re-executions, and check whether the reconstructed flow graph matches ground-truth table lineage; if the graph misses edges or recommends charts for columns not actually affected, tracing would mislead users. A second test is a larger between-subjects replication of the anomaly-location task with the baseline tool, checking whether the 100% recall gap persists when baseline users are given explicit instructions to inspect the suspect column.

Watch

Extended reading notes

Core claim

NoteFlow treats charts as "sight glasses" for intermediate data tables: after each cell execution it parses the input–operation–output triplets of pandas calls, builds a node-link graph in which each node is a snapshot of a table at a particular cell line, and recommends charts by combining transformation operations (mutate, filter, aggregate, sort, fill, replace, and others) with data facts (distribution, trend, correlation). A selected chart can then be traced backward and forward through the flow, reusing the same chart type and encodings across tables and substituting the traced column with its source column when a transformation adds or deletes columns. The paper reports that this design lets users see at a glance where a column's distribution changed, that all participants in the evaluation (12 data analysts) located the intentionally planted error line with 100% recall, and that participants rated NoteFlow clearly better than the comparison tool for understanding global data changes and locating anomalies.

Load-bearing premise

The whole system stands on the parser correctly recognizing pandas operations, table snapshots, and column-level relationships in messy, chained, out-of-order notebook code; the authors themselves note that accurate parsing of data transformations in notebooks is extremely difficult and remains an open research problem.

Editorial extensions

If this is right

  • Analysts can locate data bugs by tracing a single chart across cells instead of writing and rerunning visualization code for each state.
  • A global flow view with stepped layout lets users compare pre- and post-fix states after re-running cells, preserving execution history that most tools overwrite.
  • Chart recommendation that is aware of transformations can serve as automatic, continuous data profiling during EDA.
  • Out-of-order cell execution becomes navigable because each chart is anchored to a table snapshot with known lineage.
  • The encoding-substitution mechanism extends chart tracing to column addition and deletion, a case where naive per-table recommendation fails.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: if the parser were generalized beyond pandas (for example to polars or R data frames) or boosted with LLM-based code understanding, the same sight-glass design could cover a much larger share of real notebook workloads.
  • Editorial inference: the tracing mechanism is effectively a provenance-aware view-maintenance scheme, so formalizing the encoding substitution as view re-derivation could connect this work to database lineage research.
  • Editorial inference: a natural testable extension is live tracing inside long-running loops or model training, where charts would update during execution rather than only after a cell completes, turning the tool into a lightweight TensorBoard.
  • Editorial inference: the 100% recall result was obtained with 12 participants on two planted anomalies, so a field study with realistic, self-introduced bugs would show whether the benefit survives when users do not know an anomaly exists.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. NoteFlow is a Jupyter notebook library that parses pandas data flow, reconstructs a graph of intermediate data-table snapshots, recommends charts for each table based on transformation operations and data facts, and lets users pin a chart and trace it forward and backward through the flow with consistent encodings and automatic column substitution. The paper motivates the system through a scenario of data cleaning and anomaly location, derives challenges C1-C5 and design requirements R1-R5, describes the flow parsing, chart ranking, and tracing algorithms, and reports a within-subject user study (n=12) comparing NoteFlow with LUX on two curated notebooks. The central claim is that NoteFlow helps users trace dynamic data-table updates across the entire EDA process, and that this improves anomaly location and understanding of existing scripts, with all participants achieving a 100% recall on the anomaly-location task with NoteFlow.

Significance. If the results hold as stated, the 'sight glasses' concept is a genuinely useful contribution to EDA support in computational notebooks, moving beyond single-cell chart recommendation toward global data-flow tracing. The paper's strengths are its clearly articulated design requirements (R1-R5), the concrete prototype, and the thoughtful mechanism for consistent chart tracing with column substitution when columns are added or deleted. The qualitative feedback from participants is informative and largely consistent with the system's stated goals. However, the central claim is currently gated by two unvalidated supports: the parser in Section 4.2 is never tested for accuracy, and the quantitative user-study results in Section 6.5 are reported without any inferential statistics or effect sizes. The paper also does not release code or study materials, which limits reproducibility. The idea is defensible, but the current evidence supports only a focused proof-of-concept, not the broad claim that NoteFlow reliably lets users trace data flow in arbitrary notebooks.

major comments (3)
  1. [4.2] The flow graph produced by the parser is the foundation for all downstream components: chart recommendation, tracing, and column substitution. Yet the paper never measures parser accuracy. Section 4.2 itself states that 'Accurately parsing data transformations and semantic relationships between data tables in notebooks is extremely difficult,' and it notes that Comantics originally had no support for chaining operations. The extension to chaining operations is described only by intent ('we also extended Comantics to parsing of chaining operations with multiple transformations'), with no precision/recall numbers, no corpus evaluation, and no error analysis. A wrong parse—for example, misclassifying a chained filter/aggregate, missing an alias, or failing on a user-defined function—would silently corrupt the graph, the recommended charts, the edge directions, and the column substitution during tracing. The 100% recall in Section 6.5 therefore only demonstrates that the parser worked on the two curated study notebooks; it does not support the general claim in the abstract and conclusion. Please add a parser evaluation on a corpus of real notebooks, reporting precision/recall per transformation type (including chained operations and user-defined functions), or substantially narrow the generality of the claim.
  2. [6.5] The quantitative comparison between NoteFlow and LUX suffers from the absence of any statistical analysis. Section 6.5 reports a 100% recall for NoteFlow, describes 'varying degrees of difficulty' for LUX, and states that in successful cases NoteFlow required less time, but it provides no per-condition success counts for both notebooks, no per-participant time data, no confidence intervals, and no test such as Wilcoxon signed-rank for the within-subject design. Given n=12, the claim that 'all participants successfully located the error code line with NoteFlow' is descriptive but not inferential. The sentence 'For the successful cases, NoteFlow required less time to accomplish the task overall' is presented as a finding, yet no effect size or significance test is given. Please report the per-participant pair of results (time and success for each condition), run an appropriate non-parametric paired test, and either accompany the quantitative claims with statistical support or explicitly relabel the study as a qualitative usability probe with descriptive results only.
  3. [6.1] The evaluation tasks and the two notebooks are generated directly from the same motivating scenario and design requirements that guided the design of NoteFlow. Section 6.1 states that the tasks were designed to reflect the challenges outlined in the motivating scenario, and the two notebooks contain exactly the type of silent anomaly that the flow-tracing mechanism was built to expose. Only two notebooks are used, both appear to follow standard pandas patterns, and the paper does not report how the notebooks were constructed or whether the parser encountered any errors during the study. As a consequence, the study cannot distinguish the effect of the NoteFlow interface from the effect of the system being pre-tuned to the specific task structure. To strengthen external validity, the paper should either include notebooks that exercise less standardized or more chained transformations, report parser failures during the study, or explicitly reframe the study as a focused proof-of-concept rather than as general evidence for the tracing claim.
minor comments (4)
  1. [5.1] The text 'as mentioned in Table 4.3' should refer to Section 4.3 or Table 1; there is no Table 4.3 in the manuscript.
  2. [3.1] The word 'matploblib' appears to be a typo for 'matplotlib' in the description of the motivating scenario.
  3. [4.2] The sentence 'To be clear, the terms data tables and nodes in the following text will also be referred to as data frames' is confusing, since a node is an intermediate snapshot of a variable, not a Pandas data frame variable itself; please clarify the terminology.
  4. [6.4] The procedure reports a think-aloud protocol and screen/notebook recording but gives no information about how the recordings were analyzed (e.g., coding scheme, inter-rater reliability); a sentence on the analysis method would strengthen the qualitative claims.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: NoteFlow's claims are grounded in an empirical user study and heuristic system construction, not in a derivation that assumes its own conclusions.

full rationale

The paper's central claim is that NoteFlow's recommended charts and flow tracing help users monitor data-table evolution and locate anomalies in notebooks. This claim is supported by a comparative user study with observed behavioral outcomes (e.g., 100% recall on the anomaly-location task), not by a derivation that assumes the conclusion. The system components are constructed from explicit heuristics: flow parsing follows the pipeline of Comantics [47], chart recommendation uses transformation operations and data facts with stated ranking criteria, and chart tracing substitutes columns based on parsed transformation relationships. None of these steps define the evaluated outcome in terms of the design inputs. The tasks in the user study do mirror the motivating scenario and the design requirements (Section 6.1 explicitly says the tasks were designed to reflect the challenges from Subsection 3.1), which is a threat to external validity and a reason to interpret the evaluation cautiously, but it is not circularity because the measured outcomes are participant behaviors rather than quantities forced by the system's rules. The self-citations to Comantics and Somnus—by overlapping authors—are used as implementation components, not as proof of NoteFlow's effectiveness, and the paper itself acknowledges in Section 4.2 that accurately parsing data transformations is extremely difficult and that the extension to chaining operations is not separately validated. That is an honest limitation about parser accuracy, but it is a correctness risk, not a circular step. No fitted parameter is renamed as a prediction, no uniqueness theorem is imported from the authors' prior work, and no ansatz is smuggled in via citation. The derivation chain is therefore self-contained as an empirical HCI systems paper, and no significant circularity is present.

Assumptions & free parameters 2 free parameters · 3 assumptions · 0 invented entities

The system is a heuristic design with no numerical fits. The main unproven premises are the correctness and completeness of the parsing and transformation taxonomies inherited from prior work, which the paper itself flags as difficult open problems.

free parameters (2)
  • Chart ranking criteria priority order = Order: transformation relevance, recency, distribution, operated columns, tag count, correlation score
    Chosen by the authors based on EDA intuitions; not empirically varied or optimized in the user study (Section 4.3).
  • Selected transformation operations (12 of 30) = mutate, filter, aggregate, sort, fill, replace, unfold, extract, deduplicate, fold, separate, merge
    Subset chosen by whether the operation alters column distributions or structure; no data-driven justification (Table 1).
assumptions (3)
  • domain assumption Comantics correctly infers data transformation semantics from pandas scripts, as extended to chained operations by NoteFlow.
    Flow parsing builds directly on Comantics; if this assumption fails, the flow graph and all downstream visualization are incorrect (Section 4.2).
  • domain assumption The 30-operation taxonomy from Xiong et al. covers the transformations users apply during EDA in pandas.
    Used to identify column-add/delete operations for consistent chart tracing; gaps would break the substitution logic (Section 4.4).
  • domain assumption Pandas data frames can be instrumented to snapshot values at each line of code during execution.
    The parser stores intermediate tables as nodes; without reliable execution hooks, the flow graph cannot be built (Section 4.2).

how reviews work

0 comments
Cite this review

Pith. "Pith review of NoteFlow: Recommending Charts as Sight Glasses for Tracing Data Flow in Computational Notebooks." pith.science (2026). https://pith.science/paper/4WTE6C63

@misc{pith2026250202326,
  author       = {Pith},
  title        = {Pith review of: NoteFlow: Recommending Charts as Sight Glasses for Tracing Data Flow in Computational Notebooks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4WTE6C63}},
  note         = {Machine review of arXiv:2502.02326}
}
read the original abstract

Exploratory Data Analysis (EDA) is a routine task for data analysts, often conducted using flexible computational notebooks. During EDA, data workers process, visualize, and interpret data tables, making decisions about subsequent analysis. However, the cell-by-cell programming approach, while flexible, can lead to disorganized code, making it difficult to trace the state of data tables across cells and increasing the cognitive load on data workers. This paper introduces NoteFlow, a notebook library that recommends charts as ``sight glasses'' for data tables, allowing users to monitor their dynamic updates throughout the EDA process. To ensure visual consistency and effectiveness, NoteFlow adapts chart encodings in response to data transformations, maintaining a coherent and insightful representation of the data. The proposed method was evaluated through user studies, demonstrating its ability to provide an overview of the EDA process and convey critical insights in the data tables.

Figures

Figures reproduced from arXiv: 2502.02326 by the authors.

Figure 1
Figure 1. The Framework of NoteFlow. Given a notebook (A), the data flow is parsed and reconstructed (B). Based on the flow, NoteFlow [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Motivating scenario. The EDA process will encounter a series of challenges that require tedious efforts on programming when [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. The Interface of NoteFlow. NoteFlow contains a chart view showing the recommended charts under each cell (A & B), which [PITH_FULL_IMAGE:figures/full_fig_p011_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: The stepped layout after re-running some of the cells. The cells before (A) and after (B) the re-running correspond to the flow [PITH_FULL_IMAGE:figures/full_fig_p012_4.png]
Figure 5
Figure 5. Figure 5: The recall rate and completion time of T1 using LUX and NoteFlow. [PITH_FULL_IMAGE:figures/full_fig_p014_5.png]
Figure 6
Figure 6. Figure 6: The Result of the Likert Scale Questions in the Post-Study Questionnaire. [PITH_FULL_IMAGE:figures/full_fig_p015_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

41 extracted references · 8 canonical work pages

  1. [1]

    Ziawasch Abedjan, Lukasz Golab, and Felix Naumann. 2016. Data profiling. In 2016 IEEE 32nd International Conference on Data Engineering (ICDE) . 1432–1435. https://doi.org/10.1109/ICDE.2016.7498363

    arXiv 2016

  2. [2]

    John T Behrens. 1997. Principles and procedures of exploratory data analysis. Psychological methods 2, 2 (1997), 131

    work page 1997

  3. [3]

    Yining Cao, Jane L E, Zhutian Chen, and Haijun Xia. 2023. DataParticles: Block-Based and Language-Oriented Authoring of Animated Unit Visualizations. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems (Hamburg, Germany) (CHI ’23). Association for Computing Machinery, New York, NY, USA, Article 808, 15 pages. https://doi.org/10...

    arXiv 2023

  4. [4]

    Xi Chen, Wei Zeng, Yanna Lin, Hayder Mahdi AI-maneea, Jonathan Roberts, and Remco Chang. 2021. Composition and Configuration Patterns in Multiple-View Visualizations. IEEE Transactions on Visualization and Computer Graphics 27, 2 (2021), 1514–1524. https://doi.org/10.1109/TVCG.2020. 3030338

    doi:10.1109/tvcg.2020 2021

  5. [5]

    Yiru Chen and Eugene Wu. 2022. PI2: End-to-End Interactive Visualization Interface Generation from Queries. InProceedings of the 2022 International Conference on Management of Data (Philadelphia, PA, USA) (SIGMOD ’22). Association for Computing Machinery, New York, NY, USA, 1711–1725. https://doi.org/10.1145/3514221.3526166

    arXiv 2022

  6. [7]

    Victor Dibia and Çağatay Demiralp. 2019. Data2Vis: Automatic Generation of Data Visualizations Using Sequence-to-Sequence Recurrent Neural Networks. IEEE Computer Graphics and Applications 39, 5 (2019), 33–46. https://doi.org/10.1109/MCG.2019.2924636

    arXiv 2019

  7. [8]

    Will Epperson, Vaishnavi Gorantla, Dominik Moritz, and Adam Perer. 2023. Dead or Alive: Continuous Data Profiling for Interactive Data Science. IEEE Transactions on Visualization and Computer Graphics (2023), 1–11. https://doi.org/10.1109/TVCG.2023.3327367

    arXiv 2023

  8. [9]

    Will Epperson, Doris Jung-Lin Lee, Leijie Wang, Kunal Agarwal, Aditya G Parameswaran, Dominik Moritz, and Adam Perer. 2022. Leveraging Analysis History for Improved In Situ Visualization Recommendation. In Computer Graphics Forum

    work page 2022

Show all 41 references
  1. [10]

    Ken Gu, Eunice Jun, and Tim Althoff. 2023. Understanding and Supporting Debugging Workflows in Multiverse Analysis. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems (Hamburg, Germany) (CHI ’23). Association for Computing Machinery, New York, NY, ...

    2023

  2. [11]

    Guo, Sean Kandel, Joseph M

    Philip J. Guo, Sean Kandel, Joseph M. Hellerstein, and Jeffrey Heer. 2011. Proactive Wrangling: Mixed-Initiative End-User Programming of Data Transformation Scripts. In Proceedings of the 24th Annual ACM Symposium on User Interface Software and Technology (Santa Barbara, Calif...

    2011

  3. [12]

    Drucker, and Robert DeLine

    Andrew Head, Fred Hohman, Titus Barik, Steven M. Drucker, and Robert DeLine. 2019. Managing Messes in Computational Notebooks. InProceedings of the 2019 CHI Conference on Human Factors in Computing Systems (Glasgow, Scotland Uk) (CHI ’19). Association for Computing Machinery, ...

    2019

  4. [15]

    John, Patrick O’Flaherty, Amber Horvath, and Brad A

    Mary Beth Kery, Bonnie E. John, Patrick O’Flaherty, Amber Horvath, and Brad A. Myers. 2019. Towards Effective Foraging by Data Scientists to Find Past Analysis Choices. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems (Glasgow, Scotland Uk) (CHI ...

    2019

  5. [16]

    David Koop and Jay Patel. 2017. Dataflow Notebooks: Encoding and Tracking Dependencies of Cells. In Proceedings of the 9th USENIX Conference on Theory and Practice of Provenance (Seattle, WA) (TaPP’17). USENIX Association, USA, 17

    2017

  6. [17]

    Sam Lau, Sean Kross, Eugene Wu, and Philip J. Guo. 2023. Teaching Data Science by Visualizing Data Table Transformations: Pandas Tutor for Python, Tidy Data Tutor for R, and SQL Tutor. In Proceedings of the 2nd International Workshop on Data Systems Education: Bridging Educati...

    2023

  7. [18]

    Hearst, and Aditya G

    Doris Jung-Lin Lee, Dixin Tang, Kunal Agarwal, Thyne Boonmark, Caitlyn Chen, Jake Kang, Ujjaini Mukhopadhyay, Jerry Song, Micah Yong, Marti A. Hearst, and Aditya G. Parameswaran. 2021. Lux: Always-on Visualization Recommendations for Exploratory Dataframe Workflows. arXiv:2105...

    2021 arXiv

  8. [19]

    Haotian Li, Yong Wang, Songheng Zhang, Yangqiu Song, and Huamin Qu. 2022. KG4Vis: A Knowledge Graph-Based Approach for Visualization Recommendation. IEEE Trans. Vis. Comput. Graph. 28, 1 (2022), 195–205. https://doi.org/10.1109/TVCG.2021.3114863

    2022

  9. [21]

    Xingjun Li, Yizhi Zhang, Justin Leung, Chengnian Sun, and Jian Zhao. 2023. EDAssistant: Supporting Exploratory Data Analysis in Computational Notebooks with In Situ Code Search and Recommendation. ACM Trans. Interact. Intell. Syst. 13, 1, Article 1 (mar 2023), 27 pages. https:...

    2023 doi

  10. [22]

    Yanna Lin, Haotian Li, Aoyu Wu, Yong Wang, and Huamin Qu. 2023. DMiner: Dashboard Design Mining and Recommendation. IEEE Transactions on Visualization and Computer Graphics (2023), 1–15. https://doi.org/10.1109/TVCG.2023.3251344

    2023

  11. [23]

    Yuyu Luo, Xuedi Qin, Chengliang Chai, Nan Tang, Guoliang Li, and Wenbo Li. 2022. Steerable Self-Driving Data Visualization. IEEE Trans. Knowl. Data Eng. 34, 1 (2022), 475–490. https://doi.org/10.1109/TKDE.2020.2981464

    2022

  12. [24]

    Yuyu Luo, Xuedi Qin, Nan Tang, and Guoliang Li. 2018. DeepEye: Towards Automatic Data Visualization. In 34th IEEE International Conference on Data Engineering, ICDE 2018, Paris, France, April 16-19, 2018 . IEEE Computer Society, 101–112. https://doi.org/10.1109/ICDE.2018.00019

    2018

  13. [26]

    Jock Mackinlay. 1986. Automating the Design of Graphical Presentations of Relational Information. ACM Trans. Graph. 5, 2 (apr 1986), 110–141. https://doi.org/10.1145/22949.22950

    1986

  14. [27]

    Andrew M Mcnutt, Chenglong Wang, Robert A Deline, and Steven M. Drucker. 2023. On the Design of AI-Powered Code Assistants for Notebooks. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems (Hamburg, Germany) (CHI ’23). Association for Computing Mac...

    2023

  15. [28]

    Nelson, Halden Lin, Adam M

    Dominik Moritz, Chenglong Wang, Greg L. Nelson, Halden Lin, Adam M. Smith, Bill Howe, and Jeffrey Heer. 2019. Formalizing Visualization Design Knowledge as Constraints: Actionable and Extensible Models in Draco. IEEE Trans. Vis. Comput. Graph. 25, 1 (2019), 438–448. https: //d...

    2019

  16. [29]

    Arpit Narechania, Fan Du, Atanu R Sinha, Ryan Rossi, Jane Hoffswell, Shunan Guo, Eunyee Koh, Shamkant B Navathe, and Alex Endert. 2023. DataPilot: Utilizing Quality and Usage Information for Subset Selection during Visual Data Preparation. In Proceedings of the 2023 CHI Confer...

    2023

  17. [30]

    Hofman, and Daniel G

    Xiaoying Pu, Sean Kross, Jake M. Hofman, and Daniel G. Goldstein. 2021. Datamations: Animated Explanations of Data Analysis Pipelines. In Proceedings of the 2021 CHI Conference on Human Factors in Computing Systems (Yokohama, Japan) (CHI ’21). Association for Computing Machine...

    2021

  18. [32]

    Bahador Saket, Dominik Moritz, Halden Lin, Victor Dibia, Cagatay Demiralp, and Jeffrey Heer. 2018. Beyond Heuristics: Learning Visualization Design. arXiv:1807.06641 [cs.HC]

    2018 arXiv

  19. [33]

    Abhraneel Sarma, Alex Kale, Michael Jongho Moon, Nathan Taback, Fanny Chevalier, Jessica Hullman, and Matthew Kay. 2023. Multiverse: Multiplexing Alternative Data Analyses in R Notebooks. InProceedings of the 2023 CHI Conference on Human Factors in Computing Systems (Hamburg, ...

    2023

  20. [34]

    Danqing Shi, Xinyue Xu, Fuling Sun, Yang Shi, and Nan Cao. 2021. Calliope: Automatic Visual Data Story Generation from a Spreadsheet. IEEE Trans. Vis. Comput. Graph. 27, 2 (2021), 453–463. https://doi.org/10.1109/TVCG.2020.3030403

    2021

  21. [36]

    John W Tukey et al. 1977. Exploratory data analysis. Vol. 2. Reading, MA

    1977

  22. [37]

    Parameswaran, and Neoklis Polyzotis

    Manasi Vartak, Samuel Madden, Aditya G. Parameswaran, and Neoklis Polyzotis. 2014. SEEDB: Automatically Generating Query Visualizations. Proc. VLDB Endow. 7, 13 (2014), 1581–1584. https://doi.org/10.14778/2733004.2733035

    2014

  23. [38]

    DeLine, and Steven Mark Drucker

    April Yi Wang, Will Epperson, Robert A. DeLine, and Steven Mark Drucker. 2022. Diff in the Loop: Supporting Data Comparison in Exploratory Data Analysis. In CHI ’22: CHI Conference on Human Factors in Computing Systems, New Orleans, LA, USA, 29 April 2022 - 5 May 2022 , Simone...

    2022

  24. [39]

    Yun Wang, Zhida Sun, Haidong Zhang, Weiwei Cui, Ke Xu, Xiaojuan Ma, and Dongmei Zhang. 2020. DataShot: Automatic Generation of Fact Sheets from Tabular Data. IEEE Transactions on Visualization and Computer Graphics 26, 1 (2020), 895–905. https://doi.org/10.1109/TVCG.2019.2934398

    2020

  25. [40]

    Drucker, Titus Barik, and Robert DeLine

    Nathaniel Weinman, Steven M. Drucker, Titus Barik, and Robert DeLine. 2021. Fork It: Supporting Stateful Alternatives in Computational Notebooks. In Proceedings of the 2021 CHI Conference on Human Factors in Computing Systems (Yokohama, Japan)(CHI ’21). Association for Computi...

    2021

  26. [41]

    Kanit Wongsuphasawat, Yang Liu, and Jeffrey Heer. 2019. Goals, process, and challenges of exploratory data analysis: An interview study. arXiv preprint arXiv:1911.00568 (2019)

    2019 arXiv

  27. [42]

    Kanit Wongsuphasawat, Dominik Moritz, Anushka Anand, Jock Mackinlay, Bill Howe, and Jeffrey Heer. 2016. Towards a General-Purpose Query Language for Visualization Recommendation. In Proceedings of the Workshop on Human-In-the-Loop Data Analytics (San Francisco, California) (HI...

    2016

  28. [43]

    Kanit Wongsuphasawat, Dominik Moritz, Anushka Anand, Jock Mackinlay, Bill Howe, and Jeffrey Heer. 2016. Voyager: Exploratory Analysis via Faceted Browsing of Visualization Recommendations. IEEE Trans. Visualization & Comp. Graphics (Proc. InfoVis) (2016). http://idl.cs.washing...

    2016

  29. [44]

    Aoyu Wu, Yun Wang, Mengyu Zhou, Xinyi He, Haidong Zhang, Huamin Qu, and Dongmei Zhang. 2022. MultiVision: Designing Analytical Dashboards with Deep Learning Based Recommendation. IEEE Trans. Vis. Comput. Graph. 28, 1 (2022), 162–172. https://doi.org/10.1109/TVCG.2021. 3114826

    2022 doi

  30. [45]

    Hellerstein, and Arvind Satyanarayan

    Yifan Wu, Joseph M. Hellerstein, and Arvind Satyanarayan. 2020. B2: Bridging Code and Interactive Visualization in Computational Notebooks. In UIST ’20: The 33rd Annual ACM Symposium on User Interface Software and Technology, Virtual Event, USA, October 20-23, 2020 , Shamsi T....

    2020

  31. [46]

    Kai Xiong, Siwei Fu, Guoming Ding, Zhongsu Luo, Rong Yu, Wei Chen, Hujun Bao, and Yingcai Wu. 2023. Visualizing the Scripts of Data Wrangling With Somnus. IEEE Transactions on Visualization and Computer Graphics 29, 6 (2023), 2950–2964. https://doi.org/10.1109/TVCG.2022.3144975

    2023

  32. [47]

    Kai Xiong, Zhongsu Luo, Siwei Fu, Yongheng Wang, Mingliang Xu, and Yingcai Wu. 2023. Revealing the Semantics of Data Wrangling Scripts With Comantics. IEEE Transactions on Visualization and Computer Graphics 29, 1 (2023), 117–127. https://doi.org/10.1109/TVCG.2022.3209470

    2023

  33. [48]

    Mengyu Zhou, Qingtao Li, Xinyi He, Yuejiang Li, Yibo Liu, Wei Ji, Shi Han, Yining Chen, Daxin Jiang, and Dongmei Zhang. 2021. Table2Charts. In Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery and Data Mining . ACM. https://doi.org/10.1145/3447548.3467279 Re...

    2021

Pith tools

Reviewed August 9, 2026 · model on record in the stance chip above.