# R Markdown vs Jupyter Notebooks for Reproducible Bioinformatics R Markdown and Jupyter Notebooks solve the same problem in different languages: both weave executable code, results, and narrative text into a single document that can be rerun from raw data to final figures. The one-sentence difference is that R Markdown is a file format built around the R language and literate reporting, while Jupyter Notebook is a language-agnostic interactive environment with strong roots in Python. The rule of thumb is simple. If your analysis lives in R, especially in Bioconductor, write it in R Markdown. If your analysis lives in Python, or you need to mix languages, share interactive notebooks, or hand work to non-programmers, use Jupyter. Most bioinformatics teams eventually use both, because the question is rarely "rmarkdown or jupyter bioinformatics" as an either-or choice. The real question is which tool fits each stage of your workflow. This article compares the two on the criteria that actually decide projects: language ecosystem, execution model, reproducibility mechanics, publishing, teaching use, and how each fits into larger pipelines. It closes with worked scenarios, common mistakes, and direct answers to the questions people ask most. ## Why This Comparison Matters for Reproducible Bioinformatics Reproducibility in bioinformatics is hard for reasons that go beyond the choice of notebook. Genomic workflows chain many computationally intensive steps, where the output of one tool becomes the input of the next, and running them across heterogeneous computing environments is a well-documented challenge. The H3ABioNet consortium, a network of 27 research institutions in 17 African countries, built four shared workflows covering variant calling, 16S rDNA analysis, genotyping and genome-wide association studies, and SNP imputation precisely because implementing scalable, reproducible, and portable pipelines is difficult even for well-funded collaborative networks [1]. Notebooks address a different slice of the reproducibility problem. They sit at the analysis and reporting layer, after raw data processing, where decisions about filtering, normalization, statistics, and visualization are made. A published paper cannot describe a complex software workflow in prose alone, and interactive notebooks have been proposed specifically as a way to document and distribute bioinformatics research so that readers can execute and modify the analysis themselves [2]. Both R Markdown and Jupyter fill that role. Choosing between them well means understanding where each one is strong. ## What R Markdown Is R Markdown is a document format that combines Markdown text with fenced code chunks, typically written in R. When you knit the document, each chunk executes in a fresh R session and its output, including plots, tables, and printed values, is embedded directly in the rendered file, which can be HTML, PDF, or Word. The result is a report that regenerates itself from data. R Markdown grew out of the R ecosystem and inherits its strengths. R for bioinformatics is dominant in statistical genomics because Bioconductor, the open-source software repository for genomic data analysis, provides thousands of peer-reviewed packages for differential expression, single-cell analysis, methylation, copy number, and more. Any bioconductor tutorial you follow will almost certainly use R, and R Markdown is the natural way to run, annotate, and share that work. The mmgenome toolbox, an R package for reproducible genome extraction from metagenomes, made full reproducibility and transparency a core feature through R Markdown, so that every binning step could be recreated from the source document [3]. A minimal R Markdown document looks like this: ```` --- title: "Differential expression, mouse liver" output: html_document --- ```{r setup, include=FALSE} library(DESeq2) ``` ## Load count matrix ```{r counts} cts <- read.delim("counts.txt", row.names = 1) head(cts) ``` ```` When knitted, the `head(cts)` output appears in the final HTML. Anyone with the source file and the same package versions can rerun the entire analysis. R Markdown has since been succeeded in part by Quarto, a next-generation publishing system from the same developers that supports R, Python, and Julia. R Markdown remains in extremely wide use across published bioinformatics workflows, and the practical advice in this article applies to both. ## What a Jupyter Notebook Is A Jupyter Notebook is a JSON-based document containing cells of code, Markdown text, and rich output. Code executes in a kernel, an interactive process that holds state between cells. The default and most common kernel is IPython for Python, but kernels exist for R, Julia, Bash, and many other languages. The name Jupyter reflects the original core languages: Julia, Python, and R. Jupyter's strength is interactivity and breadth. You write a cell, run it, inspect the result, adjust, and run again. This tight loop makes notebooks the dominant medium for exploratory data analysis in Python and for teaching. Jupyter has become the standard platform for Python-based bioinformatics education, used to teach DNA sequence analysis and custom scripting in remote courses [4], adopted for active learning in introductory bioinformatics, and built into a step-by-step framework for pharmacy students with no prior programming experience [5]. Free interactive textbooks have been built on the same foundation, teaching bioinformatics fundamentals through Python 3, Jupyter Notebooks, and GitHub [6]. In production bioinformatics, Jupyter notebooks wrap real pipelines. The DIMPL pipeline for discovering structured noncoding RNA motifs in bacteria ships as a Docker image with an accompanying set of Jupyter notebooks [7]. An automated pipeline for mining genomic and proteomic variation linked to monogenic diabetes was implemented openly and flexibly in Jupyter notebooks so that researchers could tailor it to other rare diseases [8]. TeachOpenCADD provides 22 Jupyter notebooks covering cheminformatics and structural bioinformatics tasks, with automated continuous integration testing applied to the notebooks themselves [9]. ## Side-by-Side Comparison The table below is the core of the rmarkdown vs jupyter bioinformatics decision. Read it as a summary of tradeoffs, not a scorecard. | Aspect | R Markdown | Jupyter Notebook | |--|--|--| | Primary language | R, with support for Python, Bash, SQL, and others via knitr engines | Any language with a kernel, most commonly Python, also R, Julia, Bash | | File format | Plain text `.Rmd` (or `.qmd` for Quarto), clean for git diffs | JSON-based `.ipynb`, contains code, text, and stored outputs, messier for git diffs | | Execution model | Chunks execute in order at knit time, top-to-bottom in a fresh session | Cells execute interactively in any order against a persistent kernel, state can hide ordering problems | | Output and rendering | Report-oriented, knits to HTML, PDF, Word, with pagination, cross-references, and bibliographies | Screen-oriented, inline plots and tables in the live document, export via nbconvert or tools like Quarto | | Statistical genomics ecosystem | Native access to Bioconductor, the standard repository for R genomics packages | Access to R via the IR kernel, but Python library gaps exist for some Bioconductor-only methods | | Python ecosystem | Fully usable via reticulate, but secondary to the R experience | First-class, the default environment for Python data science and bioinformatics | | Interactivity | Knit-then-read workflow, reruns the whole document | Immediate cell-by-cell feedback, ideal for exploration | | Sharing with non-programmers | Rendered reports are static and polished | Can be converted into standalone web applications, as Appyters do by turning notebooks into data-driven web apps [10] | | Containerized sharing | Possible with Docker or renv | Strong tooling, BiocImageBuilder pairs Bioconductor notebooks with Binder containers so users need no local installation [2] | | Teaching fit | Excellent for statistics and reporting courses | Excellent for interactive, remote, and beginner-friendly instruction [4][5] | | Typical failure mode | Hidden chunk caching making results stale | Out-of-order cell execution producing misleading results | | Best fit | R and Bioconductor analyses, statistical reports, regulatory-style documents | Python pipelines, mixed-language work, exploration, teaching, interactive apps | ## The Difference Between R Markdown and Jupyter in Execution Model ![Two-column comparison of R Markdown and Jupyter covering when code runs, session state, rerun behaviour, typical failure and the fix.](/article-images/illustrations/rmarkdown-vs-jupyter-bioinformatics-execution-models.webp) This is the deepest difference between rmarkdown and jupyter bioinformatics workflows, and it drives most of the practical consequences. R Markdown runs deterministically by design. When you knit, every chunk executes from the top of the document to the bottom in a fresh R session. If a chunk fails or depends on an object created out of order, the knit fails or produces an error you can see. This linear execution is why R Markdown documents tend to be reliable when rerun weeks later. Options like `cache=TRUE` can speed up long-running chunks, but caching is also the most common source of stale results, which is covered in the mistakes section. Jupyter runs interactively by design. Cells hold state in a kernel that persists as long as the notebook session is open. You can define a variable in cell 10, use it in cell 3, delete a cell that created a plot, and the notebook will still show that plot until the kernel restarts. This flexibility is exactly why notebooks feel fast during exploration and exactly why they can be irreproducible when shared. The "Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks" addresses this directly, recommending that authors restart the kernel and run all cells top to bottom before sharing, pin dependencies, and treat the notebook as a narrative with a clear linear logic [11]. A practical consequence: if your deliverable is a report that a collaborator, reviewer, or regulatory body should be able to regenerate with one command, R Markdown's knit-from-top model gives you that behavior for free. If your deliverable is an interactive exploration, or an application where a user fills in a form and the notebook executes in the cloud on their data, Jupyter's model extends further. Appyters, for example, take Jupyter notebooks and turn them into standalone web-based bioinformatics applications where users upload data and set parameters, and the notebook executes remotely without the user touching code [10]. ## The Language Question: R for Bioinformatics and Python Language is often the deciding factor, and it should be decided by your domain, not by preference alone. R for bioinformatics means Bioconductor. For many genomics tasks, the reference implementation lives in R. Differential expression with DESeq2 and edgeR, single-cell workflows with Seurat and Bioconductor packages, methylation analysis with methylKit, and hundreds of other methods are published as Bioconductor packages with vignettes written in R Markdown. If your analysis depends on these packages, writing in R Markdown keeps the entire analysis, documentation, and report in one dialect. The methylKit example is instructive. A current best-practices protocol for targeted methylation sequencing splits the work into preprocessing with Trim Galore, FastQC, MultiQC, BWA-meth, Picard, and MethylDackel, then moves downstream statistical analysis, including beta-value calculation, differential methylation with methylKit, PCA, and tiling-based regional profiling, into R, all embedded in a single reproducible pipeline [12]. That downstream R stage is exactly the kind of work R Markdown handles natively. Python for bioinformatics means Biopython, scikit-bio, scanpy for single-cell, and a deep bench of general-purpose libraries for machine learning and data wrangling. It also means the Jupyter tooling ecosystem is richer: JBrowse Jupyter provides a Python interface to JBrowse 2 genome browser components directly inside notebooks [13], and the g2nb environment extends JupyterLab to connect notebooks with platforms like Galaxy, GenePattern, and Cytoscape for users who lack programming expertise [14]. GenePattern itself integrates the Jupyter environment with a server offering hundreds of analysis methods for bulk and single-cell RNA-seq, copy number, flow cytometry, and machine learning [15]. You can cross the boundary in both directions. Jupyter runs R through the IR kernel, and the BiocImageBuilder project demonstrated three Jupyter notebooks executing R and Bioconductor workflows for differential gene expression, cross-platform datasets, and RNA-seq processing, made executable in the browser through Binder containers [2]. R Markdown runs Python and Bash chunks through the reticulate and knitr engines. Mixing works, but each tool is smoother in its home language, and heavy mixing in one document usually signals that the analysis should be split into stages. ## How Each Fits Larger Pipelines ![Flowchart splitting bulk compute in a workflow engine from the notebook analysis layer, with branches for R Markdown reports and Jupyter apps.](/article-images/illustrations/rmarkdown-vs-jupyter-bioinformatics-pipeline-layers.webp) Notebooks are not workflow engines, and confusing the two is a common architectural mistake. A recent review of bioinformatics pipeline development states the situation plainly. Scripting languages, particularly Python, R, and notebooks, are popular and sufficient for small-scale pipelines intended for a single user, but they are not enough to support large-scale, shareable, maintainable, and reusable pipelines that handle large volumes of data on high-performance computing clusters. For that, scientific workflow systems such as Snakemake, Nextflow, and CWL-based systems provide modularity, reproducibility, and reuse [16]. The standard architecture looks like this: 1. Raw data processing, alignment, variant calling, and quality control run in a workflow engine, often containerized so applications behave identically across environments. Container technologies such as Docker and SingularityCE wrap applications with everything they need to run, and one HPC center deployed over 600 containerized bioinformatics applications with SingularityCE across six production systems for this reason [17]. 2. Statistical analysis, visualization, and interpretation run in a notebook, R Markdown or Jupyter, reading the workflow's output tables. 3. The notebook becomes the analysis report and the figure source. The methylation protocol mentioned earlier follows exactly this shape, with command-line preprocessing tools in one stage and R-based statistics in another, connected by quality control checkpoints and explicit reporting of intermediate outputs [12]. H3ABioNet's shared workflows similarly separate heavy computation from downstream interpretation [1]. So the honest answer to "rmarkdown or jupyter bioinformatics pipelines" is that neither replaces a workflow manager. Both are the analysis layer on top of one. ## When to Use R Markdown Choose R Markdown when most of these are true: - Your analysis is written in R and leans on Bioconductor packages. - The deliverable is a document. A paper's methods, a collaborator report, a thesis chapter, a QC summary with embedded figures, a bioconductor tutorial with runnable code. - You want one-command regeneration. Knit once, top to bottom, in a clean session. - You need formal document features. Numbered figures, captions, cross-references, citations, and a bibliography render properly in PDF and Word output. - Reviewers or collaborators need to see a report, not an environment. A rendered HTML file opens anywhere with no installation. A concrete example of R Markdown as the reproducibility backbone: the mmgenome metagenome binning toolbox integrates different binning strategies in one R package, supports visualization and validation, and obtains full reproducibility through R Markdown so every step can be recreated [3]. Binning involves many judgment calls made while looking at coverage and composition plots. Recording those judgments as interleaved narrative and code, then regenerating the whole document on demand, is precisely the job R Markdown was designed for. R Markdown also fits the reporting stage of protocol-driven work. The methylation sequencing best-practices protocol emphasizes transparency and reproducibility across analytical steps, with a modular design that allows tool substitution [12]. An R Markdown wrapper around such a pipeline gives you a living methods section that updates when parameters change. ## When to Use Jupyter Choose Jupyter when most of these are true: - Your analysis is written in Python, or mixes Python with command-line tools. - You are still exploring. Data inspection, parameter sweeps, trying three normalization approaches before committing. - You are teaching or onboarding. Jupyter's cell-by-cell feedback is the reason it dominates bioinformatics education, from remote Python-for-bioinformatics courses [4] to active-learning introductory courses to pharmacy curricula for students without programming backgrounds [5] to the free interactive textbook built on Python 3, Jupyter, and GitHub [6]. - You want to ship a tool, not just a document. Appyters convert notebooks into web applications where users submit data and parameters and get results without seeing code [10]. g2nb extends JupyterLab so non-programmers can reach Galaxy, GenePattern, and Cytoscape functionality from inside a notebook [14]. - You need interactive genomic visualization. JBrowse Jupyter embeds JBrowse 2 linear genome views inside notebooks and supports sharing through Google Colab [13]. For distribution, Jupyter has strong container-based paths. BiocImageBuilder lets users upload Bioconductor notebooks to GitHub or a private server, and Binder runs the notebook inside a software container so readers execute and modify it in a browser with no local installation and an environment mirrored to the original [2]. This pairing of notebooks with containers is one of the most practical reproducibility advances for sharing, and it applies to Python notebooks equally well. ## Worked Scenarios ### Scenario 1: RNA-seq differential expression for a publication You have a count matrix from the lab, 12 samples across two conditions, and the goal is a figure set plus methods text. Choose R Markdown. Load the counts, run DESeq2, produce PCA, volcano plots, and a heat map, and write the interpretation directly between chunks. Knit to HTML for the collaborator and keep the `.Rmd` in the paper's repository. When a reviewer asks for a different multiple-testing threshold, you change one line, reknit, and every figure and p-value table updates consistently. This workflow is the default pattern in nearly every bioconductor tutorial, because the vignette and the analysis have the same structure. A Jupyter notebook with the IR kernel could run the identical analysis, and the BiocImageBuilder work shows it is viable and shareable via Binder [2]. But you give up native document polishing, and you take on the out-of-order-cell risk during revision season, when notebooks have usually been edited dozens of times. ### Scenario 2: Wrapping a variant-calling pipeline for a lab The lab runs alignment and variant calling through a shared workflow, in the spirit of the portable multi-step pipelines H3ABioNet built for variant calling and imputation across heterogeneous computing environments [1]. You want post-processing, filtering, and a per-sample QC report. Split it. The workflow engine handles BWA, GATK, and containerized execution, since large-scale pipelines need workflow systems rather than scripts [16]. Then write two documents. An R Markdown file for the statistical QC report, with per-sample metrics as tables and plots, and a Jupyter notebook for the exploratory phase where you are still deciding call-set filters. The R Markdown report becomes the recurring deliverable, regenerated each run. The Jupyter notebook is archived once the filtering rules are frozen. ### Scenario 3: A teaching module for students new to code You need to teach sequence analysis to students with no programming background, remotely. Choose Jupyter. The published evidence base here is strongly on Jupyter's side. Remote bioinformatics courses used Jupyter to combine explanations, code, and results in a single interactive document, letting students engage directly with code and results [4]. Introductory courses adopted notebook-based active learning. A pharmacy school built its entire data science and bioinformatics curriculum on step-by-step Jupyter assignments relevant to pharmaceutical sciences [5]. The interactive textbook model extends the same approach to self-paced learners. Distribution is also solved: Binder puts a runnable notebook in a browser tab with no installation [2], which removes the single biggest barrier for a beginner class. ### Scenario 4: Making your analysis consumable by wet-lab collaborators Collaborators want to submit their own data and get results, not read code. Both tools can serve this, through different doors. Render an R Markdown report with clearly labeled input paths and a parameterized knit, or convert the Jupyter notebook into an Appyter, which presents an entry form for data upload and parameters and executes the notebook in the cloud [10]. If the collaborators are comfortable with a browser and a form, the Appyter route is more self-service. If they want a document to read and annotate, the rendered R Markdown report wins. ## Reproducibility Mechanics Beyond the Notebook Whichever notebook you choose, the notebook alone does not guarantee reproducibility. Three layers need pinning. **Package versions.** In R, use `renv` to snapshot package versions, or record `sessionInfo()` output in the document. In Python, export the environment with `pip freeze > requirements.txt` or use conda environment files. Notebook-based projects intended as teaching and research resources increasingly apply software best practices such as automated testing and continuous integration to keep notebooks runnable as dependencies evolve [9]. **System dependencies.** Bioinformatics tools bring compiler and library requirements that vary across systems. Containers solve this. Binder wraps notebooks in containers to avoid installation entirely and ensure the software environment mirrors the original [2], and SingularityCE is widely used on HPC systems for exactly this isolation, with bioinformatics applications deployed at fleet scale [17]. **Data and parameters.** Reference the input data by a stable path or a versioned download with a checksum, and state every parameter in the document rather than burying it in a cell. H3ABioNet's workflow work highlights how complex interdependent steps, where outputs feed later steps, demand explicit documentation of parameters and intermediate outputs [1], and the methylation protocol operationalizes this with harmonized parameterization and explicit reporting of intermediate outputs [12]. A notebook that runs today on your laptop is not reproducible. A notebook that runs today inside a container with pinned versions, from a fresh kernel or a clean knit, on data with a recorded checksum, is. ## Common Mistakes and Limitations **Out-of-order Jupyter cells.** The classic notebook failure. You develop cells, move things around, and the saved notebook no longer runs top to bottom. A reader who runs it gets errors or, worse, silently wrong results from stale objects. Fix: restart the kernel and run all cells before every share, a core recommendation of the ten simple rules for Jupyter analyses [11]. **Hidden R Markdown caching.** `cache=TRUE` speeds up knitting but a chunk can keep an old cached result while upstream code changed. Fix: during development knit with caching off, then cache only long, deterministic chunks, and delete the cache directory before final rendering. **Secret state in the kernel.** Packages loaded interactively, environment variables set by hand, files edited outside the notebook. None of it appears in the document, so it does not reproduce. Fix: every dependency and setup step must be a cell or chunk in the document itself. **Nondeterministic outputs.** Set seeds for any random sampling, [bootstrapping](/blog/data-analysis/what-is-bootstrapping-resampling-examples), or train-test splitting. In R Markdown, set the seed once in the setup chunk. In Jupyter, set it at the top and note that re-running a single cell can re-shuffle downstream random state. **Using a notebook as a pipeline engine.** Notebooks are the wrong tool for hundred-sample processing loops on an HPC cluster. Scripting and notebooks are sufficient for small, single-user pipelines, but large-scale, shareable, reusable pipelines need scientific workflow systems [16]. Move bulk compute into Snakemake, Nextflow, or CWL and keep the notebook for analysis. **Giant linear notebooks.** A 200-cell notebook that goes from FASTQ to figure is unreviewable. Break analyses into stages: one notebook per question, reading intermediates from disk. The modular design principle, allowing tool substitution and adaptation across stages, applies to notebooks as much as to pipelines [12]. **Unpinned environments.** "It worked last year" almost always traces to an unpinned package or system library. Record versions in the document itself, not just in a file on your machine. **Assuming one tool fits everyone.** Teams standardize on a single notebook format for convenience and then force Python work into R or R work into Python. The review literature on pipelines treats Python, R, and notebooks as complementary small-scale tools [16], and treating them as rivals creates friction without benefit. **Rendering hides kernel state in Jupyter-to-HTML exports.** Static exports of a Jupyter notebook freeze whatever output was last shown, which may not match a fresh run. If you need a static report from a Jupyter analysis, execute the notebook from a fresh kernel with nbconvert or Quarto before exporting. ## A Practical Decision Path If you want a single procedure for choosing, use this order of questions. 1. Is the core analysis in R or Python? If R with Bioconductor, start with R Markdown. If Python, start with Jupyter. 2. Is the deliverable a document or an interactive tool? Document leans R Markdown. Interactive tool or form-driven web app leans Jupyter, as the Appyters model shows [10]. 3. Will non-programmers run it? Self-service execution in a browser leans Jupyter plus Binder [2] or Appyters [10]. Reading a polished report leans rendered R Markdown. 4. Is bulk computation involved? Either way, move it to a workflow engine [16] and keep the notebook for the analysis layer. 5. Is anyone teaching or learning with it? Jupyter has the deepest track record in bioinformatics education [4][5]. Following this path usually ends with R Markdown for R-side reporting, Jupyter for Python-side analysis and teaching, and shared containerization for both. That outcome is not indecision. It is the correct architecture. ## Frequently Asked Questions ### Is R Markdown more reproducible than Jupyter? R Markdown is reproducible by default because knitting executes every chunk top to bottom in a fresh session, while Jupyter's persistent kernel allows out-of-order execution that can hide problems. A Jupyter notebook that has been restarted and run all from the top, with pinned dependencies and ideally a container, reaches equivalent reproducibility. The gap is in the defaults, not the ceiling. ### Can I run R in a Jupyter notebook? Yes. Install the IR kernel and Jupyter will run R code, including Bioconductor packages. Published examples include Jupyter notebooks running Bioconductor workflows for differential expression and RNA-seq, executed in the browser through Binder containers [2]. R Markdown remains the smoother experience for R-heavy work, particularly for polished report output. ### When should I use R Markdown instead of a Jupyter notebook? Use R Markdown when the analysis is in R, the deliverable is a rendered report or publication figure set, and you want guaranteed top-to-bottom regeneration in one command. Use Jupyter when the analysis is in Python, you are exploring interactively, teaching, or turning the analysis into an interactive application. ### Do notebooks replace Snakemake or Nextflow? No. Scripting languages and notebooks are adequate for small, single-user pipelines, but large-scale, shareable, maintainable pipelines that process large data volumes on HPC clusters require scientific workflow systems [16]. Use the workflow engine for bulk processing and the notebook for [statistical analysis](/blog/guides/statistical-analysis), visualization, and reporting, which is how modern protocols structure their stages [12]. ### How do I make my notebook reproducible for reviewers? Restart the kernel and run all cells from the top, pin every package version, record system information in the document, set random seeds, place input data or checksums under version control, and provide a container. Binder demonstrates the strongest form of this, running the notebook in a container that mirrors the original environment so readers execute it with no local installation [2]. ### Which should I learn first for R-based bioinformatics? Learn R Markdown. If your target work is R for bioinformatics, R Markdown is the format used by Bioconductor vignettes and by published reproducible workflows such as the mmgenome binning toolbox [3], and every bioconductor tutorial you follow will map directly onto an R Markdown document. Add Jupyter later if your work expands into Python. ## Sources 1. [Developing reproducible bioinformatics analysis workflows for heterogeneous computing environments to support African genomics.](https://pubmed.ncbi.nlm.nih.gov/30486782/) 2. [Reproducible Bioconductor Workflows Using Browser-based Interactive Notebooks and Containers](https://pubmed.ncbi.nlm.nih.gov/29092073/) 3. [mmgenome: a toolbox for reproducible genome extraction from metagenomes](https://doi.org/10.1101/059121) 4. [Teaching Python programming for bioinformatics with Jupyter notebook in the Post-COVID-19 era](https://pubmed.ncbi.nlm.nih.gov/37199252/) 5. [Pioneering Computational Culture Within Pharmacy Schools by Empowering Students With Data Science and Bioinformatics Skills.](https://pubmed.ncbi.nlm.nih.gov/39674347/) 6. [An Introduction to Applied Bioinformatics: a free, open, and interactive text.](https://pubmed.ncbi.nlm.nih.gov/30687845/) 7. [DIMPL: a bioinformatics pipeline for the discovery of structured noncoding RNA motifs in bacteria](https://pubmed.ncbi.nlm.nih.gov/34524415/) 8. [Bioinformatics pipeline for the systematic mining genomic and proteomic variation linked to rare diseases: The example of monogenic diabetes](https://pubmed.ncbi.nlm.nih.gov/38635808/) 9. [TeachOpenCADD 2022: open source and FAIR Python pipelines to assist in structural bioinformatics and cheminformatics research](https://pubmed.ncbi.nlm.nih.gov/35524571/) 10. [Appyters: Turning Jupyter Notebooks into data-driven web apps](https://pubmed.ncbi.nlm.nih.gov/33748796/) 11. [Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks](https://pubmed.ncbi.nlm.nih.gov/31344036/) 12. [A Guide to Enzymatic Targeted Methylation Sequencing Bioinformatics Workflow: Best Practices.](https://pubmed.ncbi.nlm.nih.gov/42848382/) 13. [JBrowse Jupyter: a Python interface to JBrowse 2](https://pubmed.ncbi.nlm.nih.gov/36648320/) 14. [Abstract 2073: Genomics to Notebook (g2nb): Extending the electronic notebook to address the needs of cancer bioinformatics](https://doi.org/10.1158/1538-7445.am2023-2073) 15. [Abstract 7426: The GenePattern ecosystem for cancer bioinformatics](https://doi.org/10.1158/1538-7445.am2024-7426) 16. [Developing and reusing bioinformatics data analysis pipelines using scientific workflow systems.](https://pubmed.ncbi.nlm.nih.gov/36968012/) 17. [Containerized Bioinformatics Ecosystem for HPC](https://doi.org/10.1109/HUST56722.2022.00006)