jupyter

Despite the widespread adoption of Jupyter Notebooks in data science, there exists no systematic empirical study of fine-grained editing behaviors during notebook development—unlike software engineering, where such analyses have advanced refactoring, security, and code completion. Method: We designed and deployed a purpose-built logging infrastructure to capture interactive development activities of 20 practitioners engaged in real-world data analysis and machine learning tasks, yielding a high-fidelity dataset comprising 2,655 cells and 9,207 executions. Contribution/Results: Our analysis reveals that notebooks serve three intertwined roles—exploratory analysis, development, and debugging—and that edits are predominantly small-scale, iterative corrections, confirming their dynamic, trial-and-error usage paradigm. This work establishes the first large-scale empirical foundation for notebook evolution research in data science, providing both actionable insights and a novel conceptual framework to guide the design of intelligent notebook tools and automated assistance systems.

This work addresses the low accuracy of large language models (LLMs) in predicting code edits during machine learning (ML) Jupyter notebook maintenance. We introduce the first large-scale, real-world, fine-grained edit dataset—comprising 48,398 cell- and line-level edits—automatically extracted and manually annotated from GitHub revision histories. We establish the first benchmark for ML notebook maintenance, revealing two key empirical patterns: edits are highly localized (mean span: 166 lines) and strongly context-sensitive. To model such edits, we propose a joint cell- and line-level edit prediction framework and conduct a systematic evaluation of LLMs across multiple scales, including zero-shot prediction and supervised fine-tuning. Results show that larger models consistently outperform smaller ones, yet overall accuracy remains limited—highlighting the intrinsic complexity of real-world ML maintenance tasks. Crucially, explicit contextual modeling is validated as the most effective pathway to performance improvement.

This work proposes Plainbook, a natural language–centric data science notebook designed to lower the barrier to entry for non-programmer researchers hindered by the code dependency of traditional Jupyter Notebooks. Plainbook automatically translates user-provided natural language descriptions into executable code while ensuring interpretability and reproducibility through a linear execution semantics and a snapshot-based kernel mechanism. By integrating both cell-level and global value validation, the system enables trustworthy, verifiable interactive data analysis without requiring users to write code manually. This approach establishes a novel paradigm that significantly democratizes access to data science for non-programming practitioners.

Existing Jupyter-style notebooks employ a linear execution model, which poorly supports data scientists’ typical nonlinear exploratory behaviors—such as backward execution, branch switching, and full-state rollback. To address this, we propose Kishuboard: a novel computational notebook system built upon two-dimensional versioning of both code and data spaces. Kishuboard introduces joint code-and-data state snapshots, constructs a dependency-aware version graph, and designs an overlayable one-dimensional history view to balance intuitiveness and expressive power. Interactive navigation controls enable flexible multi-branch state management. A user study demonstrates that Kishuboard significantly improves efficiency and task completion rates for complex exploratory workflows. By unifying and scaling versioning across code and data states, Kishuboard provides principled, extensible support for nonlinear data science workflows.

This study investigates common quality attributes characterizing high-impact Jupyter Notebooks. To address the lack of cross-platform empirical evidence on data science artifacts, we conduct the first comparative analysis of highly upvoted Kaggle notebooks and highly starred GitHub notebooks. Methodologically, we integrate exploratory data analysis, SHAP-based interpretability analysis, random forest feature importance assessment, and structural parsing of code and narrative text to systematically quantify three core dimensions: documentation completeness, modular design, and reproducibility configuration. Results show that these three features collectively account for over 75% of predictive importance for quality classification. Based on this, we propose an actionable Notebook quality assessment framework and a beginner-oriented practical guideline. This work establishes the first empirically grounded, cross-platform benchmark for evaluating Jupyter Notebooks—directly supporting pedagogy, peer review, and tool development in data science education and practice.

This work addresses the challenge of reproducibility in data visualization scripts, which often lack essential components such as source code, input data, execution environment, or output artifacts. To bridge this gap, we propose yProv4DV—a lightweight Python library that, for the first time, targets script-based visualization workflows by automatically capturing comprehensive provenance information—including source code, input data, runtime environment, and output results—through a single function call. Designed to be minimally invasive and ready-to-use, yProv4DV enables full reproducibility of visualization outputs without requiring any modification to existing scripts. This approach significantly reduces the development burden on researchers striving to ensure reproducibility and fills a critical void in automated provenance support within visualization pipelines.

This work addresses the inefficiencies researchers face in interactive computing environments due to cumbersome parameter configuration, inconsistent user interfaces, and the inability to persist settings across sessions—factors that hinder exploratory workflows and reproducibility. To overcome these challenges, the authors propose a declarative UI generation framework that, from a single specification of input parameters and validation rules, automatically renders consistent interfaces across diverse platforms such as Jupyter, Colab, and terminal-based environments. Inspired by ImageJ/FIJI, the system incorporates a persistence mechanism that serializes configurations in YAML format, enabling seamless sharing and reuse of settings across sessions and platforms. This approach significantly lowers the barrier for non-programmers to employ complex algorithms, minimizes redundant input, and enhances both experimental iteration speed and scientific reproducibility.

This work addresses the challenge that existing static analysis tools and large language models struggle to effectively detect cell-level code defects in Jupyter Notebooks. To overcome this limitation, the authors propose a fine-grained defect detection system that employs a structure-aware tokenization strategy to preserve notebook cell boundaries and integrates a machine learning–driven cell-level classification model for accurate prediction. The key contributions include a notebook-specific structure-preserving tokenization method, a dedicated cell-level defect prediction mechanism, and the construction of OtterDataset, a new benchmark comprising over 21,000 annotated samples. Experimental results demonstrate that the proposed approach achieves significantly higher F1 scores than both conventional static analyzers and large language models on two out of three benchmark datasets.

This work addresses the widespread irreproducibility of academic Jupyter Notebooks caused by environment drift, missing dependencies, and implicit execution assumptions. The authors propose the first web-oriented, automated reproducibility engineering pipeline that systematically reconstructs and evaluates repository-level execution environments for notebooks hosted on GitHub. By leveraging dependency inference, auto-generated Docker containers, and isolated execution, the pipeline enables large-scale assessment of reproducibility. A novel four-category execution outcome framework is introduced to quantify reproduction fidelity. Evaluation on 443 real-world notebooks shows that containerization resolves 66.7% of dependency-related failures; however, only 46.3% achieve high output fidelity, demonstrating that while containerization is necessary, it is insufficient for bit-for-bit reproducibility. These findings underscore the critical need for systematic reproducibility evaluation in computational research.

Jupyter notebooks are widely adopted in data science for exploratory development but suffer from weak software engineering practices, hindering reliable migration to production. To address this, we propose the first multi-agent system (MAS) specifically designed for notebook refactoring, comprising three coordinated roles—Architect, Developer, and Structure—that jointly perform end-to-end, architecture-consistent code transformation grounded in a shared dependency tree. Our approach integrates static program analysis, semantic-aware dependency modeling, and structured code generation to ensure semantics-preserving refactoring while preserving computational logic. Experimental evaluation demonstrates significant improvements in code quality—including maintainability and modularity—and effectively bridges the gap between prototyping and production deployment. The system provides a scalable, verifiable, and automated paradigm for engineering data science workflows.