@inbook {42537,
	title = {Smittestopp Backend},
	booktitle = { Smittestopp - A Case Study on Digital Contact Tracing},
	volume = {11},
	year = {2022},
	month = {06/2022},
	pages = {29 - 62},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	address = {Cham},
	abstract = {An efficient backend solution is of great importance for any large-scale system, and Smittestopp is no exception. The Smittestopp backend comprises various components for user and device registration, mobile app data ingestion, database and cloud operations, and web interface support. This chapter describes our journey from a vague idea to a deployed system. We provide an overview of the system internals and design iterations and discuss the challenges that we faced during the development process, along with the lessons learned. The Smittestopp backend handled around 1.5 million registered devices and provided various insights and analyses before being discontinued a few months after its launch.},
	isbn = {978-3-031-05465-5},
	issn = {2512-1677},
	doi = {10.1007/978-3-031-05466-2_3},
	url = {https://link.springer.com/content/pdf/10.1007/978-3-031-05466-2.pdf},
	author = {Midoglu, Cise and Ragan-Kelley, Benjamin and Reinemo, Sven-Arne and Jahren, Jon and Halvorsen, P{\r a}l},
	editor = {Elmokashfi, Ahmed and Lysne, Olav and Naumova, Valeriya}
}
@article {27765,
	title = {DIscBIO: A User-Friendly Pipeline for Biomarker Discovery in Single-Cell Transcriptomics},
	journal = {International Journal of Molecular Sciences},
	volume = {22},
	year = {2021},
	month = {Jan-02-2021},
	pages = {1399},
	publisher = {MDPI},
	abstract = {The growing attention toward the benefits of single-cell RNA sequencing (scRNA-seq) is leading to a myriad of computational packages for the analysis of different aspects of scRNA-seq data. For researchers without advanced programing skills, it is very challenging to combine several packages in order to perform the desired analysis in a simple and reproducible way. Here we present DIscBIO, an open-source, multi-algorithmic pipeline for easy, efficient and reproducible analysis of cellular sub-populations at the transcriptomic level. The pipeline integrates multiple scRNA-seq packages and allows biomarker discovery with decision trees and gene enrichment analysis in a network context using single-cell sequencing read counts through clustering and differential analysis. DIscBIO is freely available as an R package. It can be run either in command-line mode or through a user-friendly computational pipeline using Jupyter notebooks. We showcase all pipeline features using two scRNA-seq datasets. The first dataset consists of circulating tumor cells from patients with breast cancer. The second one is a cell cycle regulation dataset in myxoid liposarcoma. All analyses are available as notebooks that integrate in a sequential narrative R code with explanatory text and output data and images. R users can use the notebooks to understand the different steps of the pipeline and will guide them to explore their scRNA-seq data. We also provide a cloud version using Binder that allows the execution of the pipeline without the need of downloading R, Jupyter or any of the packages used by the pipeline. The cloud version can serve as a tutorial for training purposes, especially for those that are not R users or have limited programing skills. However, in order to do meaningful scRNA-seq analyses, all users will need to understand the implemented methods and their possible options and limitations.},
	keywords = {binder, biomarkers, Decision Trees, DEGs, ERCC spike-ins, gene filtering, Jupyter notebook, network analysis, normalization, single-cell sequencing},
	doi = {10.3390/ijms22031399},
	url = {https://www.mdpi.com/1422-0067/22/3/1399https://www.mdpi.com/1422-0067/22/3/1399/pdf},
	author = {Ghannoum, Salim and Waldir Leoncio {Netto} and Fantini, Damiano and Ragan-Kelley, Benjamin and Parizadeh, Amirabbas and Jonasson, Emma and St{\r a}hlberg, Anders and Farhan, Hesso and K{\"o}hn-Luque, Alvaro}
}
@article {27766,
	title = {Using Jupyter for reproducible scientific workflows},
	journal = {Computing in Science \& Engineering},
	volume = {23},
	year = {2021},
	month = {Jan-01-2021},
	pages = {36-46},
	publisher = {IEEE},
	abstract = {Literate computing has emerged as an important tool for computational studies and open science, with growing folklore of best practices. In this work, we report two case studies - one in computational magnetism and another in computational mathematics - where a dedicated software was exposed into the Jupyter environment. This enabled interactive and batch computational exploration of data, simulations, data analysis, and workflow documentation and outcome in Jupyter notebooks. In the first study, Ubermag drives existing computational micromagnetics software through a domain-specific language embedded in Python. In the second study, a dedicated Jupyter kernel interfaces with the GAP system for computational discrete algebra and its dedicated programming language. In light of these case studies, we discuss the benefits of this approach, including progress towards more reproducible and re-usable research results and outputs, notably through the use of infrastructure such as JupyterHub and Binder.},
	keywords = {Analytical models, Computational modeling, Documentation, Kernel, Libraries, python, Tools},
	issn = {1521-9615},
	doi = {10.1109/MCSE.2021.3052101},
	url = {https://ieeexplore.ieee.org/document/9325550},
	author = {Beg, Marijan and Belin, Juliette and Kluyver, Thomas and Konovalov, Alexander and Ragan-Kelley, Benjamin and Thiery, Nicolas and Fangohr, Hans}
}
@misc {27764,
	title = {The cloud is the limit: scaling limits of JupyterHub},
	year = {2020},
	month = {10/2020},
	address = {JupyterCon},
	abstract = {JupyterHub began as a strictly scoped project for "small-scale" Jupyter deployments. Times change. With increasing pressure to scale JupyterHub to ever larger deployments, the current architecture is reaching its limits. See an overview of the current factors limiting JupyterHub{\textquoteright}s scale what would need to change to make JupyterHub truly scalable.},
	keywords = {Cloud computing, jupyter, jupyterhub},
	url = {https://cfp.jupytercon.com/2020/schedule/presentation/223/the-cloud-is-the-limit-scaling-limits-of-jupyterhub/},
	author = {Ragan-Kelley, Benjamin}
}
@misc {27762,
	title = {Jupyter Expanding: from shell to notebook to lab and hub},
	howpublished = {JupyterCon},
	year = {2020},
	month = {10/2020},
	type = {Keynote},
	abstract = {Why did a Python shell grow a web-based notebook? Did you know IPython had at least 3 notebooks before the one we see today in Jupyter? As open source maintainers, we can find ourselves saying "sorry, out of scope" a lot. Why do we do this? How do we recognize when our scope\&nbsp;should\&nbsp;change? Take a tour of some key points in Jupyter history, such as the evolution of the notebooks, and JupyterHub.},
	url = {https://www.youtube.com/watch?v=O5zpf-dk_sQ},
	author = {Ragan-Kelley, Benjamin}
}
@misc {27763,
	title = {Measuring notebook reproducibility with repo2docker},
	year = {2020},
	month = {10/2020},
	address = {JupyterCon},
	abstract = {repo2docker powers mybinder.org, aiming to reliably turn repositories into interactive environments where notebooks can be executed, enabling reproducible interactive publications. We set out to validate repo2docker{\textquoteright}s mission of "automating existing best practices" by sampling GitHub repositories with notebooks, testing whether repo2docker creates an environment where notebooks can be executed.},
	keywords = {jupyter, reproducibility},
	author = {Vilde Dille {{\O}vreeide} and Ragan-Kelley, Benjamin}
}
@misc {26190,
	title = {Binder 2.0: Next Gen of Reproducible Scientific Environments w/ repo2docker \& BinderHub},
	howpublished = {SciPy, USA},
	year = {2018},
	abstract = {Binder is an open source web service that lets users create sharable, interactive, reproducible environments in the cloud. It is powered by other core projects in the open source ecosystem, including JupyterHub and Kubernetes for managing cloud resources. Binder works with pre-existing workflows in the analytics community, aiming to create interactive versions of repositories that exist on sites like GitHub with minimal extra effort needed. This paper details several of the design decisions and goals that went into the development of the current generation of Binder.},
	url = {https://www.youtube.com/watch?v=KcC0W5LP9GM},
	author = {Holdgraf, Chris and Ragan-Kelley, Benjamin}
}
@inproceedings {26121,
	title = {Binder 2.0 - Reproducible, interactive, sharable environments for science at scale},
	journal = {Python in Science Conference. Proceedings of the 17th Python in Science Conference},
	year = {2018},
	note = {​See the presentation at SciPy US 2018:\&nbsp;https://youtu.be/KcC0W5LP9GM},
	month = {07/2018},
	publisher = {SciPy},
	address = {Austin, Texas},
	abstract = {Binder is an open source web service that lets users create sharable, interactive, reproducible environments in the cloud. It is powered by other core projects in the open source ecosystem, including JupyterHub and Kubernetes for managing cloud resources. Binder works with pre-existing workflows in the analytics community, aiming to create interactive versions of repositories that exist on sites like GitHub with minimal extra effort needed. This paper details several of the design decisions and goals that went into the development of the current generation of Binder.},
	keywords = {binder, jupyter, open science, reproducibility},
	doi = {10.25080/Majora-4af1f417-011},
	url = {https://conference.scipy.org/proceedings/scipy2018/project_jupyter.html},
	author = {Bussonier, Matthias and Forde, Jessica and Freeman, Jeremy and Granger, Brian and Head, Tim and Holdgraf, Chris and Kelley, Kyle and Nalvarte, Gladys and Osheroff, Andrew and Pacer, M and Panda, Yuvi and Perez, Fernando and Ragan-Kelley, Benjamin and Willing, Carol}
}
@misc {26189,
	title = {Deploying a cloud-based JupyterHub for students and researchers},
	howpublished = {JupyterCon, New York, NY, USA},
	year = {2018},
	abstract = {Tutorial to demonstrate how to provide easy access to Jupyter notebooks and JupyterLab without requiring users to install anything on their computers. You{\textquoteright}ll learn how to configure and deploy a cloud-based JupyterHub using Kubernetes and how to customize and extend it for your needs.},
	keywords = {jupyter, jupyterhub},
	author = {Willing, Carol and Ragan-Kelley, Benjamin and Sundell, Erik}
}
@inproceedings {26122,
	title = {Reproducible Research Environments with Repo2Docker},
	journal = {ICML 2018 Reproducible Machine Learning},
	year = {2018},
	month = {07/2018},
	publisher = {ICML},
	abstract = {Reproducibility challenges in machine learning often center on questions of software engineering practices. Researchers struggle to reproduce another scientist{\textquoteright}s work because they cannot translate a paper into code with similar results or run an author{\textquoteright}s code. repo2docker provides a simple tool for checking the minimum requirements to reproduce a paper by building a Docker image based on a repository path or URL.  Its goal is to minimize the effort needed to convert a static repository into a working software environment. By inspecting a repository for standard configuration files used in contemporary software engineering and leveraging containerization methods, repo2docker deterministically reproduces the environment of the author so the researcher can reproduce the author{\textquoteright}s experiments.},
	keywords = {docker, jupyter, python, reproducibility},
	url = {https://openreview.net/forum?id=B1lYOwuoxm},
	author = {Forde, Jessica and Head, Tim and Holdgraf, Chris and Panda, Yuvi and Nalvarte, Gladys and Pacer, M and Perez, Fernando and Ragan-Kelley, Benjamin and Sundell, Erik}
}
@misc {25430,
	title = {3D visualization in Jupyter Notebooks},
	howpublished = {FEniCS{\textquoteright}17, Luxembourg},
	year = {2017},
	abstract = {As part of the OpenDreamKit project (www.opendreamkit.org), weare working on improving the state of 3D visualization in JupyterNotebooks (www.jupyter.org).Jupyter Notebooks run from a web browser based user interface and candisplay anything a browser can display, which includes interactivejavascript widgets and GPU accelerated 3D graphics throughWebGL. These fundamental technologies have now matured somewhat andreached widespread support, including mobile targets.The last couple of years a number of visualization projects havestarted to explore this area, including established projects such asVTK, Paraview and MayaVi, as well as newer smaller projects such asipyvolume, k3d-jupyter,\&nbsp;SciviJS, and unray the latter three being initiativesfrom the OpenDreamKit project.In this talk we will present our current work on this front, andinvite you as users and developers of FEniCS to provide your opinionson which future directions of this project that would be useful toyou.},
	author = {Martin Sandve {Aln{\ae}s} and Vidar Tonaas {Fauske} and Ragan-Kelley, Benjamin}
}
@misc {25810,
	title = {Interactive 3D Visualization in Jupyter Notebooks},
	howpublished = {EuroSciPy 2017, Erlangen, Germany},
	year = {2017},
	author = {Vidar Tonaas {Fauske} and Martin Sandve {Aln{\ae}s} and Ragan-Kelley, Benjamin}
}
@misc {25095,
	title = {Interactive CSE with IPython and Jupyter},
	howpublished = {SIAM CSE 2017, Atlanta, USA},
	year = {2017},
	publisher = {SIAM Conference on Computational Science and Engineering},
	abstract = {IPython and Jupyter provide tools for interactive computing that are widely used in science and education, and can benefit any CSE instructor, student, or researcher. We will show how to use IPython to improve your interactive explorations in Python, and how Jupyter notebooks enable interactive exploration, teaching, learning, and reproducibility, in Python as well as other languages such as MatLab, Julia, and R.The first part of the tutorial will focus on using IPython to get the most out of the tools provided by the Scientific Python community. The second part will cover Jupyter more broadly, including how working with the notebook document format can enable shareable, reproducible analyses.},
	url = {http://meetings.siam.org/sess/dsp_programsess.cfm?SESSIONCODE=61492},
	author = {Ragan-Kelley, Benjamin and Jupyter, Project}
}
@misc {25092,
	title = {Interactive Parallel Computing with Jupyter, IPython, and Dask},
	howpublished = {SOS21, Davos, Switzerland},
	year = {2017},
	url = {http://www.cscs.ch/sos21/agenda/index.html},
	author = {Ragan-Kelley, Benjamin}
}
@misc {25093,
	title = {Jupyter and IPython facilitating open access and reproducible research},
	howpublished = {2nd Conference on Non-Textual Information, Hannover, Germany},
	year = {2017},
	abstract = {Jupyter notebooks provide a document-based interactive environment for performing and recording computation.\&nbsp;Notebook documents contain not only the code that is run, but prose and mathematics for describing the analysis, as well as recording the outputs of the computation, from plain text output to rich interactive media, such as HTML and javascript or images and video. Jupyter notebooks are being deployed widely as computational companions for publications, facilitation reproduction of results, and interactive exploration and modification of analyses, including by prominent scientific discoveries such as the LIGO experiment.\&nbsp;Being freely available, open source software, Jupyter and IPython aim to improve the accessibility of reproducible practices in computational science.},
	author = {Ragan-Kelley, Benjamin and Jupyter, Project}
}
@misc {25094,
	title = {Jupyter Notebooks Facilitating Productivity, Sustainability, and Accessibility of Data Science},
	year = {2017},
	type = {Poster},
	address = {SIAM Conference on Computational Science and Engineering, Atlanta, USA},
	abstract = {Jupyter notebooks provide a document-centric web-based environment for data science and education. The web-based platform allows Jupyter to be used as a local desktop application or portal to large scale computing resources. The document aspect facilitates recording, sharing, and reproducing analyses. The integration of notebooks into existing CSE research and education workflows can improve reproducible workflows and communication and collaboration. The interactive nature of the notebook environment enables productive exploration of libraries and analyses, and being based on web technologies allows the same productivity to extend even to large-scale computing resources, which often pose a challenge to productivity and accessibility. The document nature of Jupyter notebooks facilitates preserving and sharing computations and results. Being a free, public, open source project enables equal access to all students and researchers, and the web environment is more familiar and accessible to a much wider set of current and prospective researchers than traditional terminal environments. Due to Jupyter{\textquoteright}s language agnostic protocol, with support from dozens of programming languages, notebooks can be used in many scientific and mathematical domains, which can have diverse language preferences.},
	keywords = {data science, ipython, jupyter, sustainability},
	doi = {10.6084/m9.figshare.4696414.v1},
	url = {http://meetings.siam.org/sess/dsp_talk.cfm?p=82980},
	author = {Ragan-Kelley, Benjamin and Jupyter, Project}
}
@misc {25809,
	title = {Jupyter Notebooks in Source Control: nbdime},
	howpublished = {PyData London, UK},
	year = {2017},
	type = {Lightning talk},
	author = {Vidar Tonaas {Fauske} and Ragan-Kelley, Benjamin and Martin Sandve {Aln{\ae}s}}
}
@misc {25481,
	title = {Notebooks in Version Control - diffing and merging with nbdime},
	howpublished = {Computational Mathematics with Jupyter workshop, Edinburgh, Scotland},
	year = {2017},
	author = {Vidar Tonaas {Fauske} and Ragan-Kelley, Benjamin and Martin Sandve {Aln{\ae}s}}
}
@misc {25041,
	title = {Diffing and Merging Jupyter Notebooks with nbdime},
	howpublished = {SciPy 2016},
	year = {2016},
	abstract = {Jupyter notebooks are JSON documents containing a combination of code, prose, and output. These outputs may be rich media, such as HTML or images. The use of JSON and including output can present challenges when working with version control systems and code review. The JSON structure significantly impedes the readability of diffs, and simple line-based merge tools can produce invalid results. nbdime aims to provide diff and merge tools specifically for notebooks. For diffs, nbdime will show rendered diffs of notebooks, so that the content can be compared efficiently, rather than the raw JSON. Merges performed with nbdime will guarantee a valid notebook as a result, even in the event of conflicts. nbdime integrates with existing tools, such as git, so you shouldn{\textquoteright}t need to change how you work. We hope to make the experience of collaborating on notebooks less painful and more fun.\&nbsp;},
	keywords = {git, jupyter, nbdime, notebook, version control},
	url = {http://scipy2016.scipy.org/ehome/146062/332965/},
	author = {Ragan-Kelley, Benjamin and Vidar Tonaas {Fauske} and Martin Sandve {Aln{\ae}s}}
}
@misc {25043,
	title = {Jupyter and its Horizons},
	howpublished = {EuroSciPy},
	year = {2016},
	abstract = {Project Jupyter provides building blocks for interactive and exploratory computing. These building blocks help make science reproducible across over 40 programming language (Python, Julia, R, etc.). Central to the project is the Jupyter Notebook, a web-based interactive computing platform that allows users to author data- and code-driven narratives - computational narratives - that combine live code, equations, narrative text, visualizations, interactive dashboards and other media.Jupyter is an active and growing collection of projects, split from IPython in 2015. Come learn about some of the exciting recent developments in the Jupyter project, as well as what what cool new things are coming soon. JupyterLab is the next generation of the Jupyter notebook interface. It is built on a modular javascript framework intended to allow building new applications using the Jupyter architecture, facilitating new uses of notebooks, as well as building other applications using the Jupyter architecture that are independent of notebooks. JupyterHub is a growing project for running a hosted notebook service, for classrooms or research groups, currently deployed at numerous schools and companies, big and small. Dashboards allow building interactive web applications from notebooks. ...And much more!},
	keywords = {jupyter, notebook},
	url = {https://www.euroscipy.org/2016/schedule/sessions/20/},
	author = {Ragan-Kelley, Benjamin and Jupyter, Project}
}
@inproceedings {25047,
	title = {Jupyter Notebooks: a publishing format for reproducible computational workflows},
	journal = {20th International Conference on Electronic Publishing},
	year = {2016},
	pages = {87-90},
	publisher = {IOS Press},
	abstract = {It is increasingly necessary for researchers in all fields to write computer code, and in order to reproduce research results, it is important that this code is published. We present Jupyter notebooks, a document format for publishing code, results and explanations in a form that is both readable and executable. We discuss various tools and use cases for notebook documents.\&nbsp;},
	keywords = {notebook, reproducibility, research software},
	doi = {10.3233/978-1-61499-649-1-87},
	url = {http://ebooks.iospress.nl/publication/42900},
	author = {Kluyver, Thomas and Ragan-Kelley, Benjamin and Perez, Fernando and Granger, Brian and Bussonier, Matthias and Frederic, Jonathan and Kelley, Kyle and Hamrick, Jessica and Grout, Jason and Corlay, Sylvain and Ivanov, Paul and Avila, Dami{\'a}n and Abdallah, Safia and Willing, Carol and Jupyter, Project}
}
@misc {25039,
	title = {Jupyter: Notebooks in Multiple Languages for Data Science},
	howpublished = {PyData Amsterdam},
	year = {2016},
	publisher = {PyData},
	abstract = {Jupyter notebooks have become an invaluable tool for all kinds of data science. Originally developed as part of the IPython project, notebooks have evolved from a Python specific tool to support many programming languages; more than 50 different execution kernels have now been published. For all of these languages, notebooks are a way to record and describe a data science workflow, and then share it, publicly or privately, allowing the recipients to easily modify and execute the code.We\&rsquo;ll describe the architectural changes and decisions involved in the transition to supporting multiple languages, as well as our own experience in supporting data science languages ranging from C++ to R to Bash. You\&rsquo;ll also get a high-level understanding of how to create a new kernel, if a language you\&rsquo;re excited about is not yet supported.We\&rsquo;ll also highlight some of the current development work taking place in and around Jupyter, including redesigned UI, mechanisms for collaboration on notebooks, ways to share live, executable notebooks online, and projects that reuse the Jupyter machinery in different user interfaces.},
	keywords = {data science, jupyter, notebook, python},
	url = {http://pydata.org/amsterdam2016/schedule/presentation/19/index.html},
	author = {Ragan-Kelley, Benjamin and Kluyver, Thomas and Jupyter, Project}
}
@misc {25045,
	title = {JupyterHub: Deploying Jupyter Notebooks for students and researchers},
	howpublished = {JupyterDay Orsay},
	year = {2016},
	abstract = {Since the Jupyter notebook is a web-based environment, the notebook server can be run remotely, not just on your local machine. JupyterHub is a multi-user server, aimed at helping research groups and instructors host notebook servers for their users or students. By default, JupyterHub uses the local system users and PAM authentication, but it can be customized to use any authentication system, including GitHub, CILogon, Shibboleth, and more. The way single-user servers are spawned can also be customized to use services such as Docker, Kubernetes, or HPC cluster queuing systems. The tutorial will cover a basic deployment of JupyterHub on a single machine, then extending it to use docker and GitHub authentication, as well as general best practices for JupyterHub deployment.},
	keywords = {jupyter, jupyterhub, notebook},
	url = {http://reseau-loops.github.io/journee_2016_12_jupyter.html},
	author = {Ragan-Kelley, Benjamin and Jupyter, Project}
}
@misc {25040,
	title = {JupyterHub: Deploying Jupyter Notebooks for students and researchers},
	howpublished = {PyData London},
	year = {2016},
	type = {Tutorial},
	abstract = {The Jupyter Notebook is an interactive web-based tool for interactive programming and writing code-centric documents. Being a web-based environment, the notebook server can be run remotely, not just on your local machine. JupyterHub is a multi-user server, aimed at helping research groups and instructors host notebook servers for their users or students. By default, JupyterHub uses the local system users and PAM authentication, but it can be customized to use any authentication system, including GitHub, CILogon, Shibboleth, and more. The way single-user servers are spawned can also be customized to use services such as Docker, Kubernetes, or HPC cluster queuing systems. The tutorial will cover a basic deployment of JupyterHub on a single machine, then extending it to use docker and GitHub authentication, as well as general best practices for JupyterHub deployment.},
	keywords = {jupyter, jupyterhub, notebook},
	url = {http://pydata.org/london2016/schedule/presentation/59/},
	author = {Ragan-Kelley, Benjamin and Kelley, Kyle and Kluyver, Thomas}
}
@misc {25046,
	title = {nbdime: diffing and merging notebooks},
	howpublished = {JupyterDay Orsay},
	year = {2016},
	abstract = {Jupyter notebooks are JSON documents containing a combination of code, prose, and output. These outputs may be rich media, such as HTML or images. The use of JSON and including output can present challenges when working with version control systems and code review. The JSON structure significantly impedes the readability of diffs, and simple line-based merge tools can produce invalid results. nbdime aims to provide diff and merge tools specifically for notebooks. For diffs, nbdime shows rendered diffs of notebooks, so that the content can be compared efficiently, rather than the raw JSON. Merges performed with nbdime will guarantee a valid notebook as a result, even in the event of conflicts. nbdime integrates with existing tools, such as git, so you shouldn{\textquoteright}t need to change how you work.},
	keywords = {git, jupyter, notebook, version control},
	url = {http://reseau-loops.github.io/journee_2016_12_jupyter.html},
	author = {Vidar Tonaas {Fauske} and Martin Sandve {Aln{\ae}s} and Ragan-Kelley, Benjamin}
}
@misc {25480,
	title = {nbdime: Notebook Diffing and Merging},
	howpublished = {EuroSciPy 2016, Erlangen, Germany},
	year = {2016},
	abstract = {Jupyter Notebooks have become an integral part of many scientific data projects, as it allows for intuitive combination of explanatory text, computation and (interactive) outputs. While most tools for working with Jupyter Notebooks present a neat and ordered interface, version control of Notebooks based on simple text-based diffs and merges of the JSON format can quickly become unwieldy. A prominent example is when an image in a cell{\textquoteright}s output has changed, in which case the diff will be dominated by the embedded, base64-encoded image data. Other issues involve a lack of source syntax highlighting, as well as a lack of filtering away inconsequential changes to volatile outputs and metadata.\&nbsp;To solve these issues, Nbdime implements Notebook-specific diff, patch and merge routines, as well as both command-line and browser based diff and merge tools. In this way, cell sources can be compared intuitively with syntax highlighting, volatile metadata can optionally be ignored, and output comparison can be informed by its MIME types, for example by showing side-by-side comparisons of images in the browser.},
	author = {Vidar Tonaas {Fauske} and Martin Sandve {Aln{\ae}s} and Ragan-Kelley, Benjamin}
}
@misc {25042,
	title = {Parallel Python: Analyzing Large Datasets},
	howpublished = {SciPy 2016},
	year = {2016},
	type = {Tutorial},
	abstract = {Students will walk away with a high-level understanding of both parallel problems and how to reason about parallel computing frameworks. They will also walk away with hands-on experience using a variety of frameworks easily accessible from Python. For the first half, we will cover basic ideas and common patterns encountered when analyzing large data sets in parallel. We start by diving into a sequence of examples that require increasingly complex tools. From the most basic parallel API: map, we will cover some general asynchronous programming with Futures, and high level APIs for large data sets, such as Spark RDDs and Dask collections, and streaming patterns. For the second half, we focus on traits of particular parallel frameworks, including strategies for picking the right tool for your job. We will finish with some common challenges in parallel analysis, such as debugging parallel code when it goes wrong, as well as deployment and setup strategies. Part one: We dive into common problems with a variety of tools 1. Parallel Map 2. Asynchronous Futures 3. High Level Datasets 4. Streaming Part two: We analyze common traits of parallel computing systems. 1. Processes and Threads. The GIL, inter-worker communication, and contention 2. Latency and overhead. Batching, profiling. 3. Communication mechanisms. Sockets, MPI, Disk, IPC. 4. Stuff that gets in the way. Serialization, Native v. JVM, Setup, Resource Managers, Sample Configurations 5. Debugging async and parallel code / Historical perspective We intend to cover the following tools: concurrent.futures, multiprocessing/threading, joblib, IPython parallel, Dask, Spark},
	keywords = {dask, parallel computing, python, spark},
	url = {http://scipy2016.scipy.org/ehome/146062/332960/},
	author = {Rocklin, Matthew and Ragan-Kelley, Benjamin and Zaitlen, Ben}
}
@misc {25044,
	title = {Using IPython and Jupyter for reproducible research},
	howpublished = {Swedish Bioinformatics Workshop},
	year = {2016},
	abstract = {IPython and Jupyter are free, open source tools for interactive computing, reproducible research, and communication. Learn how the web-based Jupyter notebook can help you record, share, and publish your analysis, while IPython helps with the interactive exploration, enabling more productive and more reproducible workflows. Jupyter notebooks use an open protocol, allowing you to work in many languages, including Python, R, Julia, and more.},
	keywords = {jupyter, notebook, reproducibility},
	url = {http://sbw2016.se},
	author = {Ragan-Kelley, Benjamin and Jupyter, Project}
}
