Pith. sign in

REVIEW 3 major objections 6 minor 77 references

Managing Data for Scalable and Interactive Event Sequence Visualization

T0 review · 3 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read ESeMan indexes event sequences hierarchically so parallel timeline charts fetch data in under 100 ms while preserving pixel-level visual accuracy.

desk verdict A solid systems paper with a real evaluation; the abstract overstates sub-100ms and the DuckDB baselines are underpowered, but the core mechanism is demonstrated. read the letter →

arxiv 2508.03974 v2 pith:VK2T4QMR submitted 2025-08-05 cs.HC

Sayef Azad Sakin , Katherine E. Isaacs This is my paper
classification cs.HC
keywords eventsequencevisualizationparalleltimelinechartshierarchicalindexingKD-treedatasummarizationinteractivelatencytracepixel-windowfidelity
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

The paper introduces ESeMan, a data-management library that keeps parallel timeline charts—time on one axis, tracks on the other—interactive when they show millions of events. Its idea is to pre-index events in a hierarchical spatial structure whose internal nodes store summaries of groups of events, so a query descends only as deep as the current pixel resolution demands and returns node summaries instead of individual events. In benchmarks on six program execution traces, the ESeMan configurations stayed within the 100 ms interactivity threshold for range and conditional-range queries (the largest synthetic trace reached about 0.4 s), while matching the naive full-data rendering with a structural-similarity score (SSIM) of 1.0 for the per-track structures; summed area tables, M4 aggregation, database range queries, and statistical sub-sampling were slower on most datasets. A tunable pixel window lets users trade a quantifiable amount of visual fidelity for lower fetch time.

What carries the argument

The load-bearing object is the pixel-window-aware hierarchical spatial index: a 1D KD-tree per track, a 2D KD-tree across time and tracks, or per-track agglomerative clustering, stored in a memory-mapped key-value store with an in-memory node cache populated by the previous range query. Internal nodes hold aggregate event summaries—temporal bounds and collected categorical attribute values—so a query can stop descending once a node's span is no wider than one pixel. This turns 'fetch every event in the visible range' into 'fetch the coarsest summaries that still render pixel-level truth,' and the user-set pixel window is the explicit knob that converts visual accuracy into speed.

What would settle it

Re-run the same six traces through a hand-tuned relational database pipeline (covering index on track plus start/end time, precomputed time-bucket summaries, or query rewrites) and measure fetch time and SSIM; if a tuned baseline also stays under 100 ms on the larger datasets while keeping SSIM near 1.0, the central performance claim is undercut.

Watch

Extended reading notes

Core claim

ESeMan's central claim is that hierarchical event summarization keyed to pixel width is the right data-management strategy for interactive parallel timeline charts, outperforming generic database queries, linear precomputation, and sampling-based approximations. The system stores events in a per-track one-dimensional KD-tree, a two-dimensional KD-tree across tracks and time, or a per-track agglomerative clustering; each internal node carries a summary (temporal bounds plus attribute-value lists) of all events it contains. During a fetch, traversal stops as soon as a node's time span fits within the time represented by one pixel, so sub-pixel events are returned as node summaries rather than

Load-bearing premise

The claim rests on the paper's own caveat (Section 4.9) that the database baselines were not heavily optimized and might close the gap with tuning, and on using pixel-level SSIM against its own naive rendering as the accuracy standard.

Editorial extensions

If this is right

  • Analysts can pan, zoom, and filter parallel timeline charts with millions of events without dropping data or waiting more than 100 ms for a data fetch.
  • The pixel-window dial makes the accuracy-versus-speed trade-off explicit and quantifiable in SSIM units, so an application can pick a fidelity budget and know the expected latency cost.
  • The per-track 1D KD-tree configuration is the recommended default for most uses: fastest and most accurate in the tests, with the in-memory clustering variant available when memory is tight.
  • Conditional range queries (show events in this time range that match an attribute value) also stay interactive, so filtered exploration inherits the same performance rather than reverting to slow full scans.
  • The benchmarking harness gives future data-management systems for event-sequence visualization a shared dataset and query protocol to compare against, rather than ad hoc evaluations.

Reading between the lines

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

  • If the pixel-window rule transfers to other event-sequence idioms—state timelines, hierarchical Gantt charts, or dependency-on-time views—the same index design could serve them whenever rendering resolution can be expressed as a pixel window; the paper only demonstrates parallel timelines.
  • Because the cache keeps only nodes touched by the previous range query, jump-to-random-time exploration will often run cold; the paper's repeated-query averages measure warm-cache steady state, so real-world non-sequential workflows may see less of a speedup.
  • A task-driven user study (for example, anomaly detection in traces) would test whether the SSIM-1.0 default actually preserves the perceptual patterns analysts rely on, and how wide the pixel window can go before those patterns disappear.
  • Indexing time grows steeply with dataset size (minutes to tens of minutes for millions of events in the supplement), so handling streaming or frequently updated traces would require incremental index maintenance rather than a full rebuild.
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 / 6 minor

Summary. The paper introduces ESeMan, a data-management library for parallel timeline visualizations of event sequences. ESeMan builds hierarchical KD-tree summaries (a per-track 1D KD-tree, a global 2D KD-tree, and an agglomerative-clustering variant), stores attribute summaries in internal nodes, and answers range and conditional range queries by traversing only to node spans at or below the requested pixel window, using LMDB for storage and a query-driven cache. The evaluation compares three ESeMan variants with DuckDB-based Naive, M4, statistical sub-sampling, and a summed-area-table implementation on six HPX execution traces (1.3K to 3.6M events, 8 to 496 tracks), measuring data-fetch time in a Selenium-driven browser harness and image similarity via SSIM to the Naive rendering. The paper reports that the 1D/2D KD-tree variants stay below 100 ms on all datasets except Synthesized (0.4 s), have SSIM near 1.0 at one-pixel summarization, use less memory than DuckDB-based configurations, and have INP comparable to Perfetto on one dataset. It also contributes an open-source implementation and a benchmarking harness.

Significance. If the results hold, ESeMan would be a useful contribution: it directly targets a persistent scalability problem in parallel timeline visualization, and the open-source code and benchmark harness are valuable for reproducibility and future comparisons. The evaluation is systematic in that it uses six datasets, multiple ESeMan variants, four alternative data-management strategies, repeated queries, and a pixel-level image-similarity metric. However, the headline performance claim is not yet fully supported. The sub-100ms statement in the Abstract and Conclusion is contradicted by the Synthesized result reported in §4.7.1. The DuckDB baselines are acknowledged in §4.9 to be unoptimized, and the supplemental SQL shows them to be plain scans and nonstandard M4, so the comparison may understate what a reasonably tuned database or M4 implementation could achieve. Finally, SSIM is computed against the paper's own Naive rendering, which is the exact target ESeMan was designed to match, so perfect SSIM at one-pixel summarization is partly by construction. These issues are fixable with additional experiments or carefully narrowed claims.

major comments (3)
  1. [Abstract, §4.7.1, §6] The claim of "sub-100ms fetch times" is not supported by the reported data. §4.7.1 states that ESeMan-1DKDT and ESeMan-KDT are below the interactivity threshold "except for the synthesized dataset where the data fetch takes up to 0.4 seconds," yet the Abstract and Conclusion state the sub-100ms result without qualification. The Synthesized dataset is one of the six and has 3.6M events, so this is not a negligible edge case. Please add the exception to the headline claims, or report the distribution rather than only the average, or provide a task-specific justification for why this exception is acceptable.
  2. [§4.9, Supplemental Listings C3–C5] The comparison against DuckDB baselines is the load-bearing evidence for "better performance" and is currently not a fair comparison. The paper's own limitation in §4.9 says "Queries executed over DuckDB were not heavily optimized." The supplemental SQL confirms this: the Naive query is a plain range scan over the intervals table with no secondary index on (Location, enter_timestamp, leave_timestamp); the M4 query uses a CTE over interval start/end points joined to a bucketed min/max subquery, which is not the canonical per-series M4 aggregation used in Vega-like systems; and the subsampling query uses a fixed-row reservoir sample rather than per-pixel or per-track sampling. Because DuckDB can create indexes and materialized summaries, a well-tuned implementation could plausibly meet the 100ms target on these dataset sizes, which the authors themselves suspect. Please either add an index
  3. [§4.4, Figures 1 and 6] The accuracy metric is self-referential. SSIM is computed between the ESeMan rendering and the PNG generated by the Naive configuration, which is the same Traveler rendering pipeline ESeMan was designed to approximate. At a one-pixel summarization window, ESeMan returns node summaries whose temporal bounds are designed to rasterize to the same pixels as the underlying events, so SSIM=1.0 is expected by construction and does not independently demonstrate that the summarized data preserves meaningful event information. Please supplement SSIM with renderer-independent accuracy measures, such as number of events retrieved, temporal-bound error, or precision/recall of preserved event ranges; or clearly state that the claim is only about visual equivalence to the naive rendering, not about data-level accuracy.
minor comments (6)
  1. [§3.2] The choice of the "fair splitting rule" for the 1D KD-tree and the "midpoint rule" for the 2D KD-tree is justified only by "preliminary testing." Please document the preliminary tests: which datasets were used, what criterion selected these rules, and whether the evaluation datasets were used in that selection. As written, the splitting rule is an unspecified free parameter and leaves room for overfitting.
  2. [§4.7.1] ESeMan-Agg crashes on the Fibonacci dataset with a memory allocation error and is therefore absent from that condition. This should be stated in §4.9 as a limitation, and the Conclusion should avoid attributing uniform success to all ESeMan variants.
  3. [§4.7.2] The text says "ESeMan configurations (KDT, 2DKDT, and Agg)"; there is no 2DKDT configuration in the paper. This should be "1DKDT, KDT, and Agg."
  4. [§4.7.1] Typo: "exceed the threshold four all but the smallest two datasets" should read "for all but."
  5. [§4.1, Supplemental §2] The main text states a horizontal resolution of 3672 pixels, while the supplemental M4 query says the number of bins is set to 4236. Please reconcile these numbers or clarify the relationship between canvas width, pixel window, and query bins.
  6. [§4.8] The Perfetto comparison is an informal case study on one dataset using INP, not a controlled experiment. Consider labeling it as a case study rather than a comparison, or adding a more systematic treatment.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity: performance is benchmarked against external baselines; the disclosed DuckDB-optimization caveat is a validity risk, not a circularity.

full rationale

The central performance claim—that ESeMan achieves sub-100ms fetch times while maintaining pixel-level visual accuracy—is not derived from its own inputs by construction. ESeMan is benchmarked against external systems and methods: DuckDB-based Naive queries, statistical sub-sampling, M4 aggregation, and a Summed Area Table, with four of the six configurations being non-ESeMan baselines. The ESeMan pixel-window parameter is not fitted to the reported results, and no fitted value is later relabeled as a prediction. The accuracy ground truth is the authors' own Traveler/Naive rendering, and ESeMan's 1-pixel summarization is designed so that returned node bounds fall within one pixel, making SSIM=1.0 partly a designed-in invariant rather than a surprising empirical outcome; however, this is a measurement-design choice, not a circular derivation of the performance advantage. The self-citations to Sakin et al. [60, 61] are not load-bearing: they motivate the query types and provide datasets/baselines, but the outcome does not reduce to those citations. The paper's own §4.9 limitation—'Queries executed over DuckDB were not heavily optimized. It is possible that further research in optimizing them for parallel timeline charts could close the performance gap with our indexing-based solutions'—is flagged and weighed as a genuine threat to the fairness of the comparison, but it is a correctness/validity risk, not a circularity. The same applies to the supplemental M4 query (Listing C5), which is a non-canonical adaptation for intervals; this could weaken the baseline comparison but does not make ESeMan's result equivalent to its inputs. Overall, the main derivation chain is self-contained and externally benchmarked, so the paper receives a low circularity score.

Assumptions & free parameters 1 free parameters · 5 assumptions · 0 invented entities

The central claim rests on empirical evaluation rather than derivation. The only hand-tuned design element is the KD-tree splitting rule, chosen after preliminary testing on the evaluation data. Substantive assumptions concern the validity of SSIM as an accuracy proxy, the representativeness of range queries, and the use of a single renderer/domain.

free parameters (1)
  • KD-tree splitting rules = fair splitting for 1D; midpoint with fair for 2D
    Selected after preliminary testing for highest accuracy (Section 3.2), i.e., a hand-tuned design choice against the evaluation data.
assumptions (5)
  • domain assumption Sub-pixel events should be summarized rather than drawn individually
    Section 3.1: 'We assume a pipeline in which visualization authors use ESeMan... where short events (i.e., sub-pixel events) are summarized.' This assumption defines the problem scope and the accuracy target.
  • domain assumption SSIM between PNG renders is a valid accuracy measure
    Section 4.4: 'To assess accuracy, we measured the Structural Similarity Index Measure (SSIM)... compare them to the PNG generated by the Naive configuration.'
  • domain assumption Range and conditional-range queries cover the dominant interaction patterns
    Section 4.3: 'These queries represent two of the most common query types used in parallel timeline charts as identified in the literature review by Sakin et al.'
  • domain assumption The Traveler renderer's handling of sub-pixel events is a fair ground truth
    Accuracy is computed against the Naive configuration within the same Traveler canvas (Sections 4.1 and 4.4); the pixel-level SSIM=1.0 result depends on that renderer's drawing conventions.
  • domain assumption HPX execution traces are representative of event sequence workloads
    Section 4.2 uses only HPX runtime traces plus a synthesized clone; the authors acknowledge in Section 4.9 that all datasets come from a single domain.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Managing Data for Scalable and Interactive Event Sequence Visualization." pith.science (2026). https://pith.science/paper/VK2T4QMR

@misc{pith2026250803974,
  author       = {Pith},
  title        = {Pith review of: Managing Data for Scalable and Interactive Event Sequence Visualization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VK2T4QMR}},
  note         = {Machine review of arXiv:2508.03974}
}
read the original abstract

Parallel event sequences, such as those collected in program execution traces and automated manufacturing pipelines, are typically visualized as interactive parallel timelines. As the dataset size grows, these charts frequently experience lag during common interactions such as zooming, panning, and filtering. Summarization approaches can improve interaction performance, but at the cost of accuracy in representation. To address this challenge, we introduce ESeMan (Event Sequence Manager), an event sequence management system designed to support interactive rendering of timeline visualizations with tunable accuracy. ESeMan employs hierarchical data structures and intelligent caching to provide visualizations with only the data necessary to generate accurate summarizations with significantly reduced data fetch time. We evaluate ESeMan's query times against summed area tables, M4 aggregation, and statistical sub-sampling on a variety of program execution traces. Our results demonstrate ESeMan provides better performance, achieving sub-100ms fetch times while maintaining visualization accuracy at the pixel level. We further present our benchmarking harness, enabling future performance evaluations for event sequence visualization.

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

77 extracted references · 76 canonical work pages

  1. [1]

    M. R. Ackermann, J. Bl ¤omer, D. Kuntze, and C. Sohler. Analysis of agglomerative clustering. Algorithmica, 69:184–215, 2014

    work page 2014

  2. [2]

    Agarwal, B

    S. Agarwal, B. Mozafari, A. Panda, H. Milner, S. Madden, and I. Sto- ica. Blinkdb: queries with bounded errors and bounded response times on very large data. In Pro. ACM Euro. Conf. on Comp. Sys., pp. 29–42, 2013

    work page 2013

  3. [3]

    Amazon web services x-ray

    Amazon. Amazon web services x-ray. https://aws.amazon.com/ xray/. Accessed: 2025-06-18

    work page 2025

  4. [4]

    Antweiler, D

    D. Antweiler, D. Sessler, M. Rossknecht, B. Abb, S. Ginzel, and J. Kohlhammer. Uncovering chains of infections through spatio- temporal and visual analysis of covid-19 contact traces. Comp. & Graph., 2022

    work page 2022

  5. [5]

    Zipkin - a distributed tracing system

    Apache. Zipkin - a distributed tracing system. https://zipkin. io/. Accessed: 2025-06-18

    work page 2025

  6. [6]

    Flurry analytics

    Apple. Flurry analytics. https://www.flurry.com/. Accessed: 2025-06-18

    work page 2025

  7. [7]

    X. Bai, J. Duan, B. Li, S. Fu, W. Yin, Z. Y ang, and Z. Qu. Global quantitative analysis and visualization of big data and medical de- vices based on bibliometrics. Expert Systems with Applications , 254:124398, 2024

    work page 2024

  8. [8]

    Battle, R

    L. Battle, R. Chang, and M. Stonebraker. Dynamic prefetching of data tiles for interactive visualization. In Proc. Int. Conf. on Management of Data, pp. 1363–1375, 2016

    work page 2016

Show all 77 references
  1. [9]

    Battle, R

    L. Battle, R. J. Crouser, A. Nakeshimana, A. Montoly, R. Chang, and M. Stonebraker. The role of latency and task complexity in predict- ing visual search behavior. IEEE transactions on visualization and computer graphics, 26(1):1246–1255, 2019

    2019

  2. [10]

    Battle, P

    L. Battle, P . Eichmann, M. Angelini, T. Catarci, G. Santucci, Y . Zheng, C. Binnig, J.-D. Fekete, and D. Moritz. Database benchmarking for supporting real-time interactive querying of large data. In Proc. ACM SIGMOD Int. Conf. on Management of Data , pp. 1571–1587. IEEE, 2020

    2020

  3. [11]

    Battle and C

    L. Battle and C. Scheidegger. A structured review of data management technology for interactive visualization and analysis. IEEE Trans. on Vis. & Comp. Graphics, 27(2):1128–1138, 2020

    2020

  4. [12]

    R. Bell, A. D. Malony, and S. Shende. Paraprof: A portable, exten- sible, and scalable tool for parallel performance pro le analysis. In Euro. Conf. on Parallel Proc., pp. 17–26, 2003

    2003

  5. [13]

    J. L. Bentley. Multidimensional binary search trees used for associa- tive searching. Comm. ACM, 18(9):509–517, 1975

    1975

  6. [14]

    Bernard, D

    J. Bernard, D. Sessler, J. Kohlhammer, and R. A. Ruddle. Using dash- board networks to visualize multiple patient histories: a design study on post-operative prostate cancer. IEEE transactions on visualization and computer graphics, 25(3):1615–1628, 2018

    2018

  7. [15]

    Budiu, P

    M. Budiu, P . Gopalan, L. Suresh, U. Wieder, H. Kruiger, and M. K. Aguilera. Hillview: a trillion-cell spreadsheet for big data. Proceed- ings of the VLDB Endowment , 12(11):1442–1457, 2019

    2019

  8. [16]

    Budiu, R

    M. Budiu, R. Isaacs, D. Murray, G. Plotkin, P . Barham, S. Al-Kiswany, Y . Boshmaf, Q. Luo, and A. Andoni. Interacting with large distributed datasets using sketch. Technical report, Department of Computer Sci- ences, UW-Madison, 2015

    2015

  9. [17]

    G. Cormode. Data sketching. Communications of the ACM, 60(9):48– 55, 2017

    2017

  10. [18]

    F. C. Crow. Summed-area tables for texture mapping. In Proc. Confe. on Comp. Graph. & interactive techniques , pp. 207–212, 1984

    1984

  11. [19]

    Modern application performance monitoring (apm)

    Datadog. Modern application performance monitoring (apm). https: //www.datadoghq.com/product/apm/. Accessed: 2025-06-18

    2025

  12. [20]

    Davidson, E

    T. Davidson, E. Wall, and J. Mace. A qualitative interview study of distributed tracing visualisation: A characterisation of challenges and opportunities. IEEE Trans. on Vis. & Comp. Graphics , 2023

    2023

  13. [21]

    De Pauw and S

    W. De Pauw and S. Heisig. Zinsight: A visual and analytic environ- ment for exploring large event traces. In Proc. Int. Symp. on Soft. Vis., pp. 143–152, 2010

    2010

  14. [22]

    Diehl, G

    P . Diehl, G. Daiss, K. Huck, D. Marcello, S. Shiber, H. Kaiser, J. Frank, G. C. Clayton, and D. P ¤uger. Distributed, combined cpu and gpu pro ling within hpx using apex. arXiv preprint arXiv:2210.06437, 2022

    2022 arXiv

  15. [23]

    Drebes, A

    A. Drebes, A. Pop, K. Heydemann, A. Cohen, and N. Drach-Temam. Aftermath: A graphical tool for performance analysis and debugging of ne-grained task-parallel programs and run-time systems. In Work- shop on Prog. Issues for Het. Multicores , 2014

    2014

  16. [24]

    DuckDB: Reservoir Sampling , 2025

    DuckDB Development Team. DuckDB: Reservoir Sampling , 2025. Documentation of the ‘SAMPLE ... reservoir(...)‘ SQL clause

    2025

  17. [25]

    Kibana—your window into elastic

    Elasticsearch. Kibana—your window into elastic. https://www. elastic.co/. Accessed: 2025-06-18

    2025

  18. [26]

    Eschweiler, M

    D. Eschweiler, M. Wagner, M. Geimer, A. Kn ¤upfer, W. E. Nagel, and F. Wolf. Open trace format 2: The next generation of scalable trace formats and support libraries. In Applications, Tools and Techniques on the Road to Exascale Computing , pp. 481–490. IOS Press, 2012

    2012

  19. [27]

    Ezzati-Jivan and M

    N. Ezzati-Jivan and M. R. Dagenais. Multi-scale navigation of large trace data: A survey. Concurrency and Computation: Prac. & Exp. , 29(10):e4068, 2017

    2017

  20. [28]

    Gaede and O

    V . Gaede and O. G ¤unther. Multidimensional access methods. ACM Comp. Surveys, 30(2):170–231, 1998

    1998

  21. [29]

    Perfetto - system pro ling, app tracing and trace analysis

    Google. Perfetto - system pro ling, app tracing and trace analysis. https://ui.perfetto.dev/. Accessed: 2025-06-18

    2025

  22. [30]

    Grafana: The open observability platform

    Grafana Labs. Grafana: The open observability platform. https: //grafana.com/, 2024. Accessed: 2025-06-18

    2024

  23. [31]

    Y . Guo, S. Guo, Z. Jin, S. Kaul, D. Gotz, and N. Cao. A survey on visual analysis of event sequence data. IEEE Trans. on Vis. & Comp. Graphics, 2021

    2021

  24. [32]

    Heer and D

    J. Heer and D. Moritz. Mosaic: An architecture for scalable & interop- erable data views. IEEE Transactions on Visualization and Computer Graphics, 2023

    2023

  25. [33]

    J. Heer, A. Satyanarayan, D. Moritz, K. Wongsuphasawat, J. Hullman, A. Smith, et al. V ega: A visualization grammar. https://vega. github.io/vega/, 2024. Accessed: 2025-06-18

    2024

  26. [34]

    V . N. Hirakata, M. L. R. Oppermann, V . K. Genro, and A. J. Reichelt. Exploring the gantt chart as a tool to highlight double report in case series published during the rst wave of the covid-19 pandemic. Sys- tematic Reviews, 11(1):1–7, 2022

    2022

  27. [35]

    Honeycomb

    Honeycomb. Honeycomb. https://www.honeycomb.io/trace. Accessed: 2025-06-18

    2025

  28. [36]

    S. C. Howard Chu. Lightning memory-mapped database (lmdb). http://www.lmdb.tech/. Accessed: 2025-06-12

    2025

  29. [37]

    K. E. Isaacs, P .-T. Bremer, I. Jusu , T. Gamblin, A. Bhatele, M. Schulz, and B. Hamann. Combing the communication hairball: Visualizing parallel execution traces using logical time. IEEE Trans. on Vis. & Comp. Graphics , 20(12):2349–2358, 2014

    2014

  30. [38]

    K. E. Isaacs, A. Gim ·enez, I. Jusu , T. Gamblin, A. Bhatele, M. Schulz, B. Hamann, and P .-T. Bremer. State of the art of performance visual- ization. EuroVis STARs, 2014

    2014

  31. [39]

    G. Jenks. Diskcache: Disk backed cache. https://grantjenks. com/docs/diskcache/. Accessed: 2024-09-23

    2024

  32. [40]

    J. Jo, J. Huh, J. Park, B. Kim, and J. Seo. Livegantt: Interactively visualizing a large manufacturing schedule. IEEE Trans. on Vis. & Comp. Graphics, 20(12):2329–2338, 2014

    2014

  33. [41]

    Jugel, Z

    U. Jugel, Z. Jerzak, G. Hackenbroich, and V . Markl. M4: a visualization-oriented time series data aggregation. Proceedings of the VLDB Endowment , 7(10):797–808, 2014

    2014

  34. [42]

    Kaiser, P

    H. Kaiser, P . Diehl, A. S. Lemoine, B. A. Lelbach, P . Amini, A. Berge, J. Biddiscombe, S. R. Brandt, N. Gupta, T. Heller, K. Huck, Z. Khatami, A. Kheirkhahan, A. Reverdell, S. Shirzad, M. Simberg, B. Wagle, W. Wei, and T. Zhang. Hpx - the c++ standard library for parallelism...

  35. [43]

    Kaldor, J

    J. Kaldor, J. Mace, M. Bejda, E. Gao, W. Kuropatwa, J. O’Neill, K. W. Ong, B. Schaller, P . Shan, B. Viscomi, et al. Canopy: An end-to-end performance tracing and analysis system. In Proc. Symp. on Operating Sys. Principles, pp. 34–50, 2017

    2017

  36. [44]

    S. P . Kesavan, T. Fujiwara, J. K. Li, C. Ross, M. Mubarak, C. D. Carothers, R. B. Ross, and K.-L. Ma. A visual analytics framework for reviewing streaming performance data. In 2020 IEEE Paci c Vi- sualization Symposium (Paci cVis), pp. 206–215. IEEE, 2020

    2020

  37. [45]

    S. Khan, E. Rydow, S. Etemaditajbakhsh, K. Adamek, and W. Ar- mour. Web performance evaluation of high volume streaming data visualization. IEEE Access, 11:15623–15636, 2023

    2023

  38. [46]

    Krawczuk, G

    P . Krawczuk, G. Papadimitriou, S. Nagarkar, M. Kiran, A. Mandal, and E. Deelman. Anomaly detection in scienti c work ows using end-to-end execution gantt charts and convolutional neural networks. In Practice and Experience in Advanced Research Computing 2021: Evolution Across...

    2021

  39. [47]

    Kruchten, J

    N. Kruchten, J. Mease, and D. Moritz. V egafusion: Automatic server- side scaling for interactive vega visualizations. In 2022 IEEE Visual- ization and Visual Analytics (VIS) , pp. 11–15. IEEE, 2022

    2022

  40. [48]

    J. H. Lee, S. M. Park, S. K. Kim, and L. S. Kang. Linear 4d system using schedule-location charts for infrastructure projects. Automation in Construction, 141:104413, 2022

    2022

  41. [49]

    Liu and J

    Z. Liu and J. Heer. The effects of interactive latency on exploratory visual analysis. IEEE Trans. on Vis. & Comp. Graphics, 20(12):2122– 2131, 2014

    2014

  42. [50]

    A. M. McNutt. No grammar to rule them all: A survey of json-style dsls for visualization. IEEE Transactions on Visualization and Com- puter Graphics, 29(1):160–170, 2022

    2022

  43. [51]

    Microsoft power bi

    Microsoft Corporation. Microsoft power bi. https://powerbi. microsoft.com/, 2024. Accessed: 2025-06-18

    2024

  44. [52]

    Moritz, D

    D. Moritz, D. Halperin, B. Howe, and J. Heer. Perfopticon: Visual query analysis for distributed databases. In Computer Graphics F o- rum, vol. 34, pp. 71–80, 2015

    2015

  45. [53]

    M ¤ullner

    D. M ¤ullner. fastcluster: Fast hierarchical, agglomerative clustering routines for r and python. Journal of Statistical Software , 53:1–18, 2013

    2013

  46. [54]

    L. L. Nesi, V . G. Pinto, L. M. Schnorr, and A. Legrand. Summariz- ing task-based applications behavior over many nodes through pro- gression clustering. In Int. Conf. on Parallel, Dist. & Network-Based Proc., pp. 35–42, 2023

    2023

  47. [55]

    Pasupathi, V

    S. Pasupathi, V . Shanmuganathan, K. Madasamy, H. R. Y esudhas, and M. Kim. Trend analysis using agglomerative hierarchical clustering approach for time series big data. The Journal of Supercomputing , 77(7):6505–6524, 2021

    2021

  48. [56]

    Interaction to next paint (inp)

    Philip Walton and Annie Sullivan. Interaction to next paint (inp). https://web.dev/articles/inp, 2023. Accessed: 2025-06-19

    2023

  49. [57]

    Raasveldt and H

    M. Raasveldt and H. M ¤uhleisen. Duckdb: an embeddable analytical database. In Proceedings of the 2019 International Conference on Management of Data, pp. 1981–1984, 2019

    2019

  50. [58]

    N. Relic. New relic all-in-one observability. https://newrelic. com/. Accessed: 2025-06-18

    2025

  51. [59]

    G. Roelofs. PNG: The De nitive Guide . O’Reilly Media, 1999

    1999

  52. [60]

    S. A. Sakin, A. Bigelow, R. Tohid, C. Scully-Allison, C. Scheidegger, S. R. Brandt, C. Taylor, K. A. Huck, H. Kaiser, and K. E. Isaacs. Trav- eler: Navigating task parallel traces for performance analysis. IEEE Trans. on Vis. & Comp. Graphics, 29(1):788–797, 2022

    2022

  53. [61]

    S. A. Sakin and K. E. Isaacs. A literature-based visualization task taxonomy for gantt charts. In 2024 IEEE Visualization and Visual Analytics (VIS), pp. 1–5. IEEE, 2024

    2024

  54. [62]

    Salesforce

    I. Salesforce. Tableau: Business intelligence and analytics software. https://help.tableau.com/current/pro/desktop/ en-us/buildexamples_gantt.htm. Accessed: 2025-06-18

    2025

  55. [63]

    Satyanarayan, D

    A. Satyanarayan, D. Moritz, K. Wongsuphasawat, and J. Heer. V ega- lite: A grammar of interactive graphics. IEEE Trans. on Vis. & Comp. Graphics, 23(1):341–350, 2016

    2016

  56. [64]

    Servicenow cloud observability

    ServiceNow. Servicenow cloud observability. https://lightstep. com. Accessed: 2025-06-18

    2025

  57. [65]

    Q. Shen, Z. Y ou, X. Y an, C. Zhang, K. Xu, D. Zeng, J. Qin, and B. Tang. Qevis: Multi-grained visualization of distributed query exe- cution. IEEE Transactions on Visualization and Computer Graphics , 30(1):153–163, 2023

    2023

  58. [66]

    Y . Sun, Y . Zhang, A. Mosallaei, M. D. Shah, C. Dunne, and D. Kaeli. Daisen: A framework for visualizing detailed gpu execution. In Com- puter Graphics F orum, vol. 40 number 3, pp. 239–250, 2021

    2021

  59. [67]

    W. Tao, X. Hou, A. Sah, L. Battle, R. Chang, and M. Stonebraker. Kyrix-s: Authoring scalable scatterplot visualizations of big data. IEEE Trans. on Vis. & Comp. Graphics , 27(2):401–411, 2020

    2020

  60. [68]

    W. Tao, A. Sah, L. Battle, R. Chang, and M. Stonebraker. Kyrix-j: Visual discovery of connected datasets in a data lake. In CIDR, 2022

    2022

  61. [69]

    Jaeger - a distributed tracing system

    Uber. Jaeger - a distributed tracing system. https://www. jaegertracing.io/. Accessed: 2025-06-18

    2025

  62. [70]

    Undozerov

    V . Undozerov. Spring diagrams for the visualization of construction project dynamics. In E3S Web of Conferences , vol. 263, p. 04052. EDP Sciences, 2021

    2021

  63. [71]

    V an Der Donckt, J

    J. V an Der Donckt, J. V an Der Donckt, E. Deprost, and S. V an Hoecke. Plotly-resampler: Effective visual analytics for large time series. In 2022 IEEE Visualization and Visual Analytics (VIS), pp. 21–25. IEEE, 2022

    2022

  64. [72]

    Z. Wang, A. C. Bovik, H. R. Sheikh, and E. P . Simoncelli. Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 13(4):600–612, 2004

    2004

  65. [73]

    J. M. Wilson. Gantt charts: A centenary appreciation. European Jour- nal of Operational Research, 149(2):430–437, 2003

    2003

  66. [74]

    Y eshchenko, C

    A. Y eshchenko, C. Di Ciccio, J. Mendling, and A. Polyvyanyy. Visual drift detection for event sequence data of business processes. IEEE Transactions on Visualization and Computer Graphics , 28(8):3050– 3068, 2021

    2021

  67. [75]

    Y eshchenko and J

    A. Y eshchenko and J. Mendling. A survey of approaches for event se- quence analysis and visualization. Information Systems, 120:102283, 2024

    2024

  68. [76]

    Y . Zhao, Y . Wang, J. Zhang, C.-W. Fu, M. Xu, and D. Moritz. Kd-box: Line-segment-based kd-tree for interactive exploration of large-scale time-series data. IEEE Trans. on Vis. & Comp. Graphics , 28(1):890– 900, 2021. Supplemental Materials - Managing Data for Scalable and In...

    2021

  69. [2020]

    doi: 10.21105/joss.02352

    doi

Pith tools

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