jupyter notebook presentation

• presentation

Create Presentation from Jupyter Notebook

You don't need to install any additional framework to make a presentation from Jupyter Notebook. Jupyter is using Reveal.js library for creating slides. However, I strongly recommend to install RISE ( R eveal.js I Python S lideshow E xtension) extension. It greatly simplifies the process of slide creation with a live preview.

The outline for this article:

• create a simple notebook with one chart,
• convert notebook to a slideshow,
• presentation development with RISE extension,
• parameterized presentations,
• publishing presentation.

Create Jupyter Notebook

Let's create a Jupyter notebook. It will have a few Markdown and Python cells.

Please notice that we can mix Python variables with Markdown thanks to IPython.display.Markdown() function:

The output of the above code cell will contain a Markdown. There is a simple scatter plot in the notebook for randomly generated points:

The matplotlib scatter plot:

It is a simple notebook created for example purposes. There is no limit on the number of slides or cells. From my experience, I was creating a presentation with more than 70 slides with many plots/images, and the slideshow was working smoothly, even with the presentation published as a website (hosted in the cloud).

Create Presentation

The notebook is saved in ipynb format . The next step is to convert it to a slideshow. We need to provide information on how to use cells in the presentation. Please click View ➡️ Cell Toolbar ➡️ Slideshow .

Each cell will have a toolbar with the select widget. You can select there how cells will be used in the presentation:

• Slide - the cell will be a new slide;
• Sub-Slide - the cell will be shown in the current slide as a replacement for previous content. It will be available in arrow-down navigation;
• Fragment - the cell will appear in the current slide, it will append to the previous content. It will be available in arrow-down and arrow-right navigation;
• Skip - the content will not be displayed in the presentation;
• Notes - notes for slide, the cell content is not displayed in the presentation;

Please select the Slide Type for every cell and save the notebook.

How to create a presentation for Jupyter Notebook? We need to use the nbconvert tool. It is installed with Jupyter Notebook. There is a command for converting notebook to presentation:

You can open the output file presentation.slides.html in the web browser (just double-click on the file). Alternatively, you can serve slides with jupyter ; slides will be available at http://127.0.0.1:8000/presentation.slides.html :

There are several ways to hide the code in the presentation, one of them is to pass --no-input parameter to nbconvert :

The presentation with hidden code:

It is possible to convert the Jupyter Notebook presentation into PDF slides. One of the ways to do this is to add ?print-pdf in the URL in a web browser while displaying HTML format:

The presentation will be in a format ready to print. To save it as a PDF, just print the website with Save as PDF selected for the destination.

RISE Extension

There is a RISE extension that may be helpful for developing presentations in Jupyter Notebook. It can be easily installed with pip or conda :

You get a small chart icon in the top toolbar after installation. You switch between the notebook and presentation views by clicking on the chart icon.

What is more, you can edit the code in presentation mode. The RISE extension doesn't have the option to hide the code ( GitHub issue discussion about hiding code feature in RISE repository ). If you would like to hide/show the code during the presentation development, you need to install an additional extension called hide_code .

Parameterized Presentation

What if you would like to change or recompute charts in the presentation based on user input? There is an open-source framework called Mercury that makes it possible.

You can easily add interactive widgets to the presentation and publish it with Mercury . Widgets are added based on the YAML header. They are directly connected with Python variables in the notebook. User changes, tweak widgets, and execute the notebook with new values. The slides in the presentation will be automatically recomputed.

The video from an interactive presentation about Mercury :

Publishing Presentation

The final presentation is in HTML format. You can publish it as a static website. There are several ways to publish Jupyter Notebook; you can host it on GitHub Pages, Netlify, or Vercel. If you are using Mercury framework for parameterized presentations, you can host it in the cloud (soon, there will be available online service runmercury.com for hosting notebooks).

Jupyter Notebook Presentations might be a great alternative to traditional presentation software. You will save time by building the presentation in the same environment where your code is. Any update in code or chart change will immediately affect the presentation - no need to manually copy-paste results. The parameterized presentation can take your slides one step further. Imagine your supervisor or manager playing with your slides and recomputing new charts.

Create interactive slides with Python in 8 Jupyter Notebook cells

Creating presentations in Jupyter Notebook is a great alternative to manually updating slides in other presentation creation software. If your data changes, you just re-execute the cell and slide chart is updated.

Jupyter Notebook is using Reveal.js (opens in a new tab) for creating slides from cells. The standard approach is to write slides code and Markdown in the Jupyter Notebook. When notebook is ready, it can be exported to standalone HTML file with presentation.

What if, you would like to update slides during the slide show? What is more, it would be fantastic to have interactive widgets in the presentation. You can do this in Mercury framework.

In this tutorial, we will create an interactive presentation in Jupyter Notebook and serve it with Mercury.

Create presentation in notebook

Please enable Slideshow toolbar in Jupyter Notebook. It can be done by clicking View -> Cell Toolbar -> Slideshow . It is presented in the screenshot below:

We will need following packages to create presentation in Python notebook:

Please make sure that they are installed in your environment.

1. Import packages and App setup

The first step is to import packages and setup Mercury App :

We setup title and description for App object.

Please note that we set Slide Type to Skip . This cell will not appear in the presentation.

2. Add title

The second cell is a Markdown with title:

The Slide Type is set to Slide . It is our first slide!

3. Add slide with Markdown

Add new Markdown cell with the following cell.

Please set Slide Type to Slide . It will be a second slide. I'm using ## as slide title ( # will produce too large title in my opinion).

4. Add Mercury Widget

Please add code cell with Text widget. We will use it, to ask users about their name.

We set Slide Type as Skip , so this cell will not appear in the presentation.

5. Display name

Let's use the name.value in the slide. Please add a code cell. We will display a Markdown text with Python variables by using Markdown function from Mercury package.

Please set the Slide Type to Slide .

You can display Markdown with Python variables by calling mr.Markdown() or mr.Md() functions. Both do the same.

The first five cells of the notebook:

You can enter your name in the widget during the notebook development. There will be no change in other cells. If you want to update the cell with new widget value, please execute it manually.

6. More widgets

We can add more widgets to the presentation. They will be used to control chart in the next slide.

We have used Slider and Select widgets. They are displayed in the notebook. This cell will not be displayed in the presentation, so set Slide Type to Skip .

7. Scatter plot

We will add a new code cell. It will have Slide Type set to Slide .

We used widgets values by accessing them with samples.value and color.value .

Screenshot of the notebook with scatter plot:

8. Final slide

Please add a last Markdown cell. Its Slide Type will be set to Slide :

Please notice that link is added with HTML syntax. There is a target="_blank" used to open link in a new tab.

Run presentation in Mercury

Please run Mercury local server in the same directory as notebook:

The above command will open a web browser at http://127.0.0.1:8000 . Please click on a card with presentation.

You can navigate between slides with arrows in the bottom right corner. You can enter the full screen mode by pressing F on the keyboard. Please use Esc to exit full screen mode.

You can change widgets values in the sidebar and presentation slides will be automatically recomputed:

You can export your slides as PDF or HTML by clicking Download button in the sidebar.

Presenting with Jupyter Notebooks

The best way to walk through this tutorial is using the accompanying jupyter notebook:.

[ Jupyter Notebook ]

In the last year I’ve started presenting work using Jupyter Notebooks, rebelling against the Bill Gates'-driven status-quo. Here I’ll explain how to do it. It’s not difficult, but in my opinion makes presentations look slicker, whilst allowing you to run code live in a presentation if you like. First, we need to download the plug-in that gives us the presentation functionality, it’s called RISE . We can do this easily using pip in a terminal window:

Once installed, our first move is to add the presentation toggles to our notebook cells. We do this by clicking View in the menu bar, then Cell Toolbar , then Slideshow :

Adding Presentation Toggles to Cells

Slide types.

This adds a Slide Type dropdown to each cell in the notebook. Here we can choose one of five options:

• Slide : Used to start a new chapter in your presentation, think of this as a section heading in LaTeX.
• Sub-slide : Slide falling within the chapter defined by a Slide cell.
• Fragment : this is to split the contents of one slide into pieces; a cell marked as a fragment will create a break inside the slide; it will not show up right away, you will need to press Space one more time to see it.
• Skip : Skips cell when in presenter mode.
• Notes : Cell that allows the author to write notes on a slide that aren’t shown in presenter view.

As with any notebook, we can define the cell type to be either Markdown or Code . As you’d expect, we present any text or image-based slide in Markdown , reserving the Code cell type if and only if we want to explicitly run some code in the presentation. If you aren’t familiar, Markdown is a straightforward language for text formatting; I won’t go into the details here, but suffice to say you can learn the basics of Markdown in 5 minutes. You can find a useful cheatsheet here .

Adding images is easy too. I advise creating a sub-directory in your working directory called /images and storing anything you want to present there. Then you display them in a markdown file using some simple HTML syntax:

<img class="" src="images/london_deaths.jpeg" style="width:75%">

You can manipulate the style attribute to change the size of the image. Don’t worry, this is the only HTML you need to know!

Entering Presentation Mode

To view your slideshow click on the bar-chart button in the menu bar. This will start the presentation from the cell currently selected:

That’s it! This tutorial has given you an introduction to the basics of RISE for presenting with Jupyter Notebooks, you can of course customise these to your heart’s content using further plug-ins and more advanced Markdown. Here’s a summary of the useful links from this document to finish:

• RISE Documentation
• Markdown Cheatsheet
• Markdown Table Generator

Twitter: @enjeeneer

Website: https://enjeeneer.io/.

Create a slide deck using Jupyter Notebooks

There are many options when it comes to creating slides for a presentation. There are straightforward ways, and generating slides directly from Jupyter is not one of them. But I was never one to do things the easy way. I also have high expectations that no other slide-generation software quite meets.

Why transition from slides to Jupyter?

I want four features in my presentation software:

• An environment where I can run the source code to check for errors
• A way to include speaker notes but hide them during the presentation
• To give attendees a useful handout for reading
• To give attendees a useful handout for exploratory learning

More Great Content

• Free online course: RHEL technical overview
• Learn Advanced Linux Commands
• Download Cheat Sheets
• Find an Open Source Alternative
• Read Top Linux Content
• Check out open source resources

There is nothing more uncomfortable about giving a talk than having someone in the audience point out that there is a coding mistake on one of my slides. Often, it's misspelling a word, forgetting a return statement, or doing something else that becomes invisible as soon as I leave my development environment, where I have a linter running to catch these mistakes.

After having one too many of these moments, I decided to find a way to run the code directly from my slide editor to make sure it is correct. There are three "gotchas" I needed to consider in my solution:

• A lot of code is boring. Nobody cares about three slides worth of import statements, and my hacks to mock out the socket module distract from my point. But it's essential that I can test the code without creating a network outage.
• Including boilerplate code is almost as boring as hearing me read words directly off of the slide. We have all heard (or even given) talks where there are three bullet points, and the presenter reads them verbatim. I try to avoid this behavior by using speaker notes.
• There is nothing more annoying to the audience when the talk's reference material doesn't have any of the speaker notes. So I want to generate a beautiful handout containing all of my notes and the slides from the same source. Even better, I don't want to have slides on one handout and a separate GitHub repository for the source code.

As is often the case, to solve this issue, I found myself reaching for JupyterLab and its notebook management capabilities.

Using Jupyter Notebooks for presentations

I begin my presentations by using Markdown and code blocks in a Jupyter Notebook, just like I would for anything else in JupyterLab. I write out my presentation using separate Markdown sections for the text I want to show on the slides and for the speaker notes. Code snippets go into their own blocks, as you would expect.

Because you can add a "tag" to cells, I tag any cell that has "boring" code as no_markdown .

(Moshe Zadka, CC BY-SA 4.0 )

Then I convert my Notebook to Markdown with:

There are ways to convert Markdown to slides —but I have no idea how to use any of them and even less desire to learn. Plus, I already have my favorite presentation-creation tool: Beamer .

But Beamer requires custom LaTeX, and that is not usually generated when you convert Markdown to LaTeX. Thankfully, one Markdown implementation– Pandoc Markdown —has a feature that lets me do what I want. Its raw_attribute extension allows including "raw" bits of the target format in the Markdown.

This means if I run pandoc on the Markdown export from a notebook that includes raw_attribute LaTeX bits, I can have as much control over the LaTeX as I want:

The --listings makes pandoc use LaTeX's listings package, which makes code look much prettier. Putting those two pieces together, I can generate LaTeX from the notebook.

Through a series of conversion steps, I was able to hide the parts I wanted to hide by using:

• LaTeX raw_attribute bits inside Jupyter Notebook's Markdown cells
• Tagging boring cells as no_markdown
• Jupyter's "nbconvert" to convert the notebook to Markdown
• Pandoc to convert the Markdown to LaTeX while interpolating the raw_attribute bits
• Beamer to convert the Pandoc output to a PDF slide-deck
• Beamer's beamerarticle mode

All combined with a little bit of duct-tape, in the form of a UNIX shell script, to produce slide-deck creation software. Ultimately, this pipeline works for me. With these tools, or similar, and some light UNIX scripting, you can make your own customized slide created pipeline, optimized to your needs and preferences.

What is the most complicated pipeline you have ever used to build a slide deck? Let me know about it—and whether you would use it again—in the comments.

Edit images with Jupyter and Python

Who needs to learn an image-editing application when you can do the job with open source tools you already know?

JupyterLab teaches Python developers magic

JupyterLab, the successor to Jupyter Notebook, feels like playing video games with the cheat codes enabled.

Markdown beginner's cheat sheet

Learn Markdown syntax to be ready to contribute to open source software.

Related Content

Nikolai Janakiev

All things data // data science / data engineering / data visualization / GIS

© 2024. All rights reserved.

home · about · projects

Creating Slides with Jupyter Notebook

Table of contents, preparation, convert slides for reveal.js, serve slides with https server, export as pdf.

Jupyter notebook is a powerful tool to interactively code in web-based notebooks with a whole plethora of programming languages. With it, it is also possible to create web-based slideshows with reveal.js .

The slides functionality is already included in Jupyter Notebook, so there is no need to install plugins. Although slides do not work at the time of writing for JupyterLab . To open the slides toolbar for each cell in your Jupyter Notebook, enable it via View > Cell Toolbar > Slideshow :

Now you can specify for each cell what kind of slide type you want. The available types are Slide (new slide), Sub-Slide (new slide below last one), Fragment (fragment within previous slide), Skip (skip this cell) and Notes (adding speaker notes):

You can now convert the notebook with the jupyter-nbconvert command line tool and the --to slides option. First, you need to add/clone reveal.js into your folder with the presentation ( git clone https://github.com/hakimel/reveal.js/ ) and then you can run the command:

If you want to enable scrolling you can add the following to the jupyter nbconvert command (thanks to Hannah Augustin for the hint):

It is also possible serve slides with an https server by using the --post serve option as in the command:

This will run a server which opens the presentation in your browser ready for presentation. Another neat thing is RISE , a Jupyter slideshow extension that allows you to instantly turn your Jupyter Notebooks into a slideshow with the press of a button in your notebook:

Finally, if you want to create a PDF from your slides, you can do that by adding ?print-pdf to the url of the previously hosted slides:

After opening this url, you can now print the page to PDF. You can find other configuration options in the nbconvert documentation .

Happy presenting!

Related Posts

Installing and running jupyter on a server 12 feb 2019, manage jupyter notebook and jupyterlab with systemd 10 nov 2020, remove jupyter notebook output from terminal and when using git 06 nov 2021.

Creating presentations from Jupyter notebooks

January 12, 2022

2022   ·   python   jupyter   data visualization  

The Jupyter notebook, controversial though it may be , is a core data exploration and experimentation platform for many in the data and scientific communities. In particular, its combination of REPL-like input and embedded HTML output make for an ideal means of generating and analyzing data tables and visualizations. This is great for sharing information with others – and, it turns out, the Jupyter ecosystem includes tooling to quickly generate reveal.js presentations using the included nbconvert library.

Getting started

For local service, you’ll need to provide a path to the reveal.js library. It’s probably easiest to clone it into the working directory of your notebook:

Then, run the export command to initiate the reveal.js service:

The --to option actually accepts a number of possible output formats, including PDF (try jupyter nbconvert --help to see other options), but the slides argument targets reveal.js slides. --reveal-prefix should point to your local reveal.js directory, and --post serve specifies that the reveal.js serve command should be run following conversion (a tab containing the live presentation should be opened on your default browser).

By default, every cell is treated as a unique slide, but you have some basic control over how cells are turned into reveal.js objects. First, select the “slideshow” view from the menu:

You can choose from a few different slide types for each cell:

“Sub-slide” creates a separate slide which is grouped within the closest “Slide” (in reveal.js presentations, lateral movement will change parent “Slide” groups, while vertical movement will proceed within an individual slide grouping). A “fragment” will be conjoined to the previous slide/sub-slide, but will be revealed on an extra enter/arrow-key press/click (sort of like the “appear” animation in Powerpoint progressively reveals individual bullet points).

A few closing notes:

The nbconvert docs suggest reverting your reveal.js source to version 3.5 (via git checkout 3.5.0 in the reveal.js repo). I found that this broke some things and do not recommend it.

Jupyter notebooks don’t immediately auto-save state, so remember to click the “save and checkpoint” button before exporting to ensure that you capture the most recent iteration of your work.

Theoretically the HTML output should be able to pull requisite scripting from a reveal.js CDN, but it didn’t seem to work for me ¯\_(ツ)_/¯ . Maybe there are more --reveal-prefix related options? Who knows.

Critically, reveal is flexible about sizing for a lot of things, but will struggle with images (and probably code output), so make sure to double-check that any visual output looks right in a presentation beforehand (you may need to resize it)

Natalie B. Hogg

Cosmologist

Using a Jupyter notebook to make presentation slides

• Open a blank Jupyter notebook.
• Add a cell and convert it to Markdown (either esc + m ) or by using the drop down menu at the top of the notebook.
• Add your text, equation or image to the cell (images can be added via the edit menu, though some HTML tags may be needed to render and/or resize the image).
• Choose a slide type in the drop down menu of the cell itself (slide, sub-slide, fragment, skip or notes).
• Save the notebook.
• In the terminal, run jupyter nbconvert *.ipynb --to slides .
• Open the resulting .html file in a browser and use the arrow keys to navigate.

I turn coffee Lapsang Souchong tea into code; if you found this post useful you can contribute to my habit here: https://ko-fi.com/nataliebhogg .

I’m in a strange kind of limbo at the moment. I’m not being paid, since I can’t sign my new contract without being physically present in Spain. And, until the 30th of March, it was physically impossible to enter Spain unless you were a Spanish resident, since the borders were closed due to Covid restrictions. Due to Brexit, I also need a visa in order to be able to stay in Spain for more than ninety days and to legally work there. So, I have an appointment at the Spanish consulate in London on Friday to submit my visa application. I’m hoping for a quick decision so I can book a flight, get to Madrid, sign my contract and start working (and drawing a salary). But, until then, I’m in this strange, semi-working state.

I could have taken this time off completely, but with the UK in lockdown and everything shut, I know I would have quickly got bored in the face of a two or three month holiday with nothing to do and nowhere to go. So, I resolved to keep working, despite the lack of pay, albeit at a reduced pace. I’ve been attending journal clubs and mainly working on turning a chapter of my PhD thesis into a paper.

As a result, it was nice to take a full five days off over the Easter weekend. I finished reading three books: Island of Dreams by Dan Boothby (ok if you are interested in Gavin Maxwell, Scotland or otters), The Nine Tailors by Dorothy L. Sayers (which I highly recommend!) and Never Split the Difference by Chris Voss (probably only useful if you’re a hostage negotiator or someone working in big business). It was a conscious decision to try and read more and I’m glad it paid off. I always forget how refreshed I feel after even just a couple of days off from work.

This morning I finished making my slides for my talk at Britgrav next week. I’m going to be presenting my work from a few months ago on how the distance duality relation can be constrained with standard sirens and how modified gravity effects can bias this type of analysis. I tend to use either Google Slides or LaTeX Beamer to make presentations, depending on the content and audience, but this time I decided to use Markdown in a Jupyter Notebook which I then converted to HTML.

This produces very clean looking slides, and it’s easy to write LaTeX commands too (unlike in Google Slides).

The process I followed to create the slides is very simple.

The same week that I’m giving this talk, I’m also presenting the H0 review paper by Di Valentino et al (we’re having a special H0 tension week, as someone else is going to present Efstathiou’s recent offering on the same topic) and the following week I’ve been invited to give a seminar at my old undergraduate institution, Aberystwyth University, which I’m really looking forward to.

Share this:

• Click to share on Twitter (Opens in new window)
• Click to share on Facebook (Opens in new window)

Natalie Hogg

Leave a comment Cancel reply

• Already have a WordPress.com account? Log in now.
• Subscribe Subscribed
• Copy shortlink
• Report this content
• View post in Reader
• Manage subscriptions
• Collapse this bar

• Python Course
• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

Create Presentations Using RISE in Jupyter Notebook

RISE is an extension of Jupyter Notebook designed to revolutionize the way you create presentations. By seamlessly integrating with Jupyter Notebook, RISE allows you to transform your static code and data into dynamic, interactive presentations. In this guide, we’ll explore how to install RISE, set up presentation slides, view and present your slides, and delve into the additional features of using the RISE chalkboard for enhanced interactivity.

Installation of RISE

Let’s start with the basics. Installing RISE is the first step towards creating engaging presentations in Jupyter Notebook . To install RISE, follow these simple steps:

Open your terminal, use the following command, and press shift+enter to execute the command:

python -m pip install RISE

Steps to Create Presentations using RISE in Jupyter

Now, let’s move on to setting up your presentation slides. You will find the RISE icon on the top of the Jupyter Notebook page.

Setting Up Presentation Slides

Setting up presentation slides involves configuring the slide types and layout for your presentation.

• Open Jupyter Notebook.
• Click on the ‘View’ menu at the top of the notebook.
• Select ‘Cell Toolbar’ from the dropdown menu.
• Choose ‘Slideshow’ from the options available.

Now that you’ve configured your slide types and layout, it’s time to prepare your slides.

Preparing Slides

Creating compelling content for your slides is essential to captivate your audience. Follow these steps to prepare your slides:

• Create new cells in the notebook for each slide’s content.
• Assign different slide types to cells based on their purpose, such as Slide, Subslide, Fragment, Skip, or Notes.

Determine the slide types you’ll use:

• Slide: The content on this slide is self-explanatory. A new slide will start from this cell.
• Subslide: Type of slide that will appear under the current slide
• Fragment: If you want to control the flow of information on your slide, divide it into fragments.
• Skip: skip this cell, it won’t appear on the slide.
• Notes: This cell works as notes.
• “ — ”: Inherit behavior from the cell above.

Example: Here’s an example of slide preparation using different slide types:

Viewing Presentation

Before presenting to your audience, it’s crucial to preview how your presentation will appear. Here’s how you can do it:

• Run the notebook by clicking the ‘Run’ button or pressing Shift + Enter.
• Navigate through the slides using the space bar, arrow keys, or other navigation controls provided by RISE.

Now that you’ve previewed your presentation, Follow these steps to start presenting:

• Utilize the presentation mode by pressing the appropriate shortcut.
• Navigate through your slides seamlessly using the space bar, arrow keys, or other navigation controls.

How to Use RISE Chalkboard

Now, let’s explore the additional feature of RISE: the chalkboard. The chalkboard feature allows you to annotate your slides in real time, adding a layer of interactivity to your presentation. Here’s how you can use the RISE chalkboard:

• Enable the chalkboard mode by clicking on the chalkboard icon in the presentation mode.
• Use your mouse or touchpad to draw or write on the slides.
• Erase or clear annotations as needed to maintain clarity.

With the RISE chalkboard, you can engage your audience and make your presentations more interactive and dynamic.

Please Login to comment...

Similar reads.

• Jupyter-notebook

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Creating a Presentation with Jupyter Notebook and RISE (Video)

In this tutorial, you will learn how to use Jupyter Notebooks to create slide show presentations. This allows you to run and edit live code in your slides.

Want to learn more about Jupyter Notebook? Then check out my book, Jupyter Notebook 101 , available on Leanpub , Amazon , and Gumroad

Things Michael Thinks

Data science in learning, creating an interactive presentation with jupyter notebook and plotly.

Let’s say you have performed some analysis using Jupyter notebook and produced some great visualisations to back up your finding. How would you present this to your stakeholders and other people? One great way to ace this is to convert your jupyter notebook and plotly graphs to an interactive presentation that can impress people.

Introduction

I learned on creating slides using Jupyter Notebook from Tahsin Mayeesha’s medium post . However, I was curious to see if I can incorporate interactive graphs from Plotly in the slides. Therefore, I wrote this post to share what I’ve learned.

For this post, I will use the Titanic dataset from Kaggle . This dataset is a classic dataset used to learn machine learning models on classification problems.

In this case, my aim was to present my finding from an Exploratory Data Analysis on the Titanic dataset. I would include several visualisations and slides to show what you can do with Jupyter markdown and slides. Although I would use Plotly mostly for the slides, I have also included one plot with Seaborn and one plot from Pandas Profiling library to show the possibilities you can do.

For my presentation, I imported the following visualisation libraries.

• Plotly, including the Plotly Express and Plotly Graph Objects
• Pandas Profiling visualisation for missing values in the dataframe.

All the libraries above are not required to make the slides work, you can just simply use Plotly , Seaborn , or even simply Matplotlib . You can check the full notebook on my GitHub repo here .

Jupyter Notebook Slideshow View and Setting

Changing the view will allow you to set what type of slides you want for each cell. There are 5 Slide Types you can select:

• Slide . This is the main content of a slide. You can place markdown, visuals, or even code here.
• Sub-Slide . I will consider this as a new slide with transition animation. You have to use the down arrow navigation to access it from the main slide (Slide type).
• Fragment . This will be a part or component of the immediate previous cell with Slide Type. For example, one cell with the heading will be set as Slide and the visualisation will be set as Fragment. The fragment will be inside the main slide but with a fade-in transition.
• Skip . This cell will not be shown on the slides. Perfect for code and comment cells that you won’t show. Be aware that you can’t put skip for your visualisation code because the output will not be shown as well.
• Notes . This will create Speaker notes, but I haven’t tried this function. From the NbConvert reference , you need to have a local copy of the Reveal.JS file to allow you having a presenter view with the notes.

Skip type for Non-Visualisation Code Cell

Slide type for Title and Markdown Cell

For the first slide or the cover, I will only use one markdown cell with title, subtitle, and author.

Slide + Fragment types for Mixture of Markdown and Code Cells

Hiding the Codes on the Slide

Specific for Plotly

If you use plotly, then you need to pay attention in this section. Otherwise, your plotly graphs won’t show up in the slides.

Plotly will require its JavaScript file ( plotly.js ) to produce the graph. There are three options you can choose:

• A local copy of JavaScript file. This is the easiest and simplest way to ensure the Plotly graphs to work. You can download the latest JS file from this link and rename it into plotly.js. This file needs to be in the same folder or directory with the resulting HTML slides file.
• Refer to CDN online. This is a great option if you want a lightweight HTML file and have constant access to the Internet. This is perfect if you want to embed the slides on a website. To do this, create a new code cell at the beginning, include this code here: from IPython.display import Javascript Javascript ( """require.config({ paths: { plotly: 'https://cdn.plot.ly/plotly-latest.min' } });""" )

The get_plotlyjs function would return the whole minified Plotly JS script and by using the Javascript function from IPython we include this in the notebook. The resulting file would be 3MB larger because of the inclusion. However, you will only have one HTML file that you can just send or use anytime.

Converting the Notebook to Slides

To produce the slides from the jupyter notebook, run the following code on your command prompt or bash:

Here we are calling nbconvert function that can be used to convert the notebook into slides (HTML format with Reveal.js) or other formats as can be referred on the documentation .

The TagRemovePreprocessor will remove any code with to_remove tag as we specified. Again, this can be replaced with any other tag you specified before hand.

If you check your directory, the html version of your notebook will be there. You can open this on the web browser and use the directional pad on the screen or arrow keys on your keyboard to navigate. I was able to open the file and interact with Plotly graphs successfully using Chrome, Firefox, Opera, and Microsoft Edge. I heard this might not work so well with Safari but I can’t confirm this.

For me personally, I found that using --post serve , I could not terminate the server using Ctrl-C as described even after many tries. However, I also found that I can omit this in my command prompt and still get the HTML slides file.

Final Output of the Slides

Here are the following slides I produced from my jupyter notebook that you can find on GitHub

• Manage Email Subscriptions
• How to Post to DZone
• Article Submission Guidelines
• Manage My Drafts

2024 DZone Community Survey: Tell us what's in your tech stack. Help us build a better DZone. Enter for a chance to win swag!

Database Systems: In 2024, the focus around databases is on their ability to scale and perform in modern data architectures. See why.

Data Pipeline Essentials: Dive into the fundamentals of data pipelines and the problems they solve for modern enterprises.

• Norm of a One-Dimensional Tensor in Python Libraries
• Improving Sentiment Score Accuracy With FinBERT and Embracing SOLID Principles
• Apache Flink
• How To Use Amazon SageMaker for Machine Learning
• OpenTelemetry Tracing on Spring Boot: Java Agent vs. Micrometer Tracing
• Harnessing DevOps Potential: Why Backup Is a Missing Piece
• K3s vs. Talos Linux
• Automation Resilience: The Hidden Lesson of the CrowdStrike Debacle

Creating Presentations With Jupyter Notebook

When you build a presentation using jupyter notebook, you'll be able to run code live from your slides..

Join the DZone community and get the full member experience.

Jupyter Notebook can be turned into a slide presentation that is kind of like using Microsoft PowerPoint, except that you can run the slide's code live! It's really neat how well it works. The only con in my book is that there isn't a lot of theming that can be applied to your slides, so they do end up looking a bit plain.

In this article, we will look at two methods of creating a slideshow out of your Jupyter Notebook. The first method is by using Jupyter Notebook's built-in slideshow capabilities. The second is by using a plug-in called RISE .

Let's get started!

The first thing we need to do is to create a new Notebook. Once you have that done and running, let's create three cells so that we can have three slides. Your Notebook should now look like the following:

An empty notebook with 3 cells

Now let's turn on the "slideshow" tools. Go to the View menu and then click on the Cell Toolbar menu option. You will find a sub-menu in there that is called Slideshow . Choose that. Now your Notebook's cell should look like this:

An empty slideshow

There are now little comboboxes on the top right of each cell. These widgets give you the following options:

You can just create a series of Slides if you like, but you can make the slideshow a bit more interesting by adding Sub-Slides and Fragments. Sub-slides are just slides that are below the previous one while Fragments are basically fragments within the previous slide. As an aside, I have actually never used Fragments myself. Anyway you can also set a slide to Skip, which just allows you to skip a slide or Notes, which are just speaker notes.

Let's add some text to our first cell. We will add the text "# Hello Slideshow" to it and set the cell type to Markdown. Note the pound sign at the beginning of the text. This will cause the text to be a heading.

In cell two, we can add a simple function. Let's use the following code:

For the last cell, we will add the following text:

Make sure you set that to be a Markdown cell as well. This is what my cells ended up looking like when I was done:

Getting the slideshow ready

To make things simple, just set each of the cell's individual comboboxes to Slide .

Now we just need to turn it into an actual slideshow. To do that, you will need save your Notebook and shut down the Jupyter Notebook server. Next you will need to run the following command:

Running the slideshow

To navigate your slideshow, you can use your left and right arrow keys or you can use spacebar to go forward and shift_spacebar to go back. This creates a pretty nice and simple slideshow, but it doesn't allow you to run the cells. For that, we will need to use the RISE plugin!

Getting Started With RISE

Reveal.js - Jupyter/IPython Slideshow Extension (RISE) is a plugin that uses *reveal.js* to make the slideshow run live. What that means is that you will now be able to run your code in the slideshow without exiting the slideshow. The first item that we need to learn about is how to get RISE installed.

Installing rise with conda

If you happen to be an Anaconda user, then this is the method you would use to install RISE:

This is the easiest method of installing RISE. However most people still use regular CPython, so next we will learn how to use pip!

Installing rise with pip

You can use Python's pip installer tool to install RISE like this:

You can also do `python -m pip install RISE` if you want to. Once the package is installed, you have a second step of installing the JS and CSS in the proper places, which requires you to run the following command:

If you somehow get a version of RISE that is older than 5.3.0, then you would also need to enable the RISE extension in Jupyter. However, I recommend just using the latest version so you don't have to worry about that.

Using RISE for a SlideShow

Now that we have RISE installed and enabled, let's re-open the Jupyter Notebook we created earlier. Your Notebook should now look like this:

Adding RISE

You will notice that I circled a new button that was added by RISE to your Notebook. If you mouse over that button you will see that it has a tooltip that appears that says "Enter/Exit RISE Slideshow." Click it and you should see a slideshow that looks a lot like the previous one. The difference here is that you can actually edit and run all the cells while in the slideshow. Just double-click on the first slide and you should see it transform to the following:

Running with RISE

After you are done editing, press SHIFT+ENTER to run the cell. Here are the primary shortcuts you will need to run the slideshow effectively:

• SPACEBAR - Goes forward a slide in the slideshow
• SHIFT+SPACEBAR - Goes back a slide in the slideshow
• SHIFT+ENTER - Runs the cell on the current slide
• DOUBLE-CLICK - To edit a Markdown cell

You can view all the Keyboard shortcuts by going to the Help menu when not in Slideshow mode and clicking the Keyboard Shortcuts option. Most — if not all — of these shortcuts should work inside a RISE slideshow.

If you want to start the slideshow on a specific cell, just select that cell and then press the Enter Slideshow button.

RISE also works with Notebook widgets. Try creating a new cell with the following code:

Now start the slideshow on that cell and try running the cell (SHIFT+ENTER). You should see something like this:

Using a widget in RISE

You can use RISE to add neat widgets, graphs and other interactive elements to your slideshow that you can edit live to demonstrate concepts to your attendees. It's really quite fun and I have used RISE personally for presenting intermediate-level material in Python to engineers.

RISE also has several different themes that you can apply as well as minimal support for slide transitions. See the documentation for full information.

Wrapping Up

In this chapter we learned about two good methods for creating presentations out of our Jupyter Notebooks. You can use Jupyter directly via their nbconvert tooling to generate a slideshow from the cells in your Notebook. This is nice to have, but I personally like RISE better. It makes the presentations so much more interactive and fun. I highly recommend it. You will find that using Jupyter Notebook for your presentations will make the slides that much more engaging and it is so nice to be able to fix slides during the presentation too!

Related Reading

• Presenting code using  Jupyter Notebook
• The RISE  Github page
• Jupyter nbconvert  Usage
• How to build interactive presentations with  Jupyter Notebook and Reveal JS

Published at DZone with permission of Mike Driscoll , DZone MVB . See the original article here.

Opinions expressed by DZone contributors are their own.

Partner Resources

• About DZone
• Send feedback
• Community research
• Advertise with DZone

CONTRIBUTE ON DZONE

• Become a Contributor
• Core Program
• Visit the Writers' Zone
• Terms of Service
• Privacy Policy
• 3343 Perimeter Hill Drive
• Nashville, TN 37211
• [email protected]

Let's be friends:

• Subscription

The Dataquest Download

Level up your data and ai skills, one newsletter at a time., the real power of python functions & jupyter notebook.

Hey, Dataquesters!

I hope you enjoyed last week’s exploration of Python’s basic operators and data structures. This week, we’re going to build on that foundation by exploring Python functions and Jupyter Notebook. With functions and Jupyter Notebook, you’ll be able to write more efficient code and tackle complex projects with confidence.

When I first learned about Python functions, I immediately loved how they simplified my code. Recently, as you may recall from the previous newsletter, I put this knowledge to work at Dataquest by creating the script to automate generating course prerequisites. This task used to take hours of manual work, but with functions, I streamlined the process significantly. Each function in my script handled a specific task, like extracting course metadata or writing prerequisites to a file. This modular approach made my code easier to understand and maintain.

Now, let’s talk about what exactly Python functions are. Think of them as reusable blocks of code that perform specific tasks. They’re like little machines you build once and can use over and over again. Functions help you avoid repeating code, make your programs more organized, and break down complex problems into manageable pieces.

One of the key features of functions is their ability to accept arguments and return values. Arguments are like inputs that you feed into your function, while return values are the outputs your function produces. For example, in my prerequisite script, I created a function that took a course number as an argument and returned a list of prerequisite courses.

A tool that’s been invaluable in my function-writing journey is Jupyter Notebook. This interactive environment lets you write and test code in small chunks, making it perfect for developing and debugging functions. In my prerequisite automation project, I used Jupyter Notebook to test each function individually before integrating them into my final script.

Jupyter Notebook is ideal for data analysis because it allows you to mix code with explanatory text, making your analysis easy to follow and share with others. You can also run code cells independently, which is great for iterative development and experimentation. Plus, you can easily create visualizations right in the notebook, helping you understand your data better.

When it comes to debugging functions, I’ve found a few techniques particularly helpful. One of my favorites is using print statements to track the flow of data through a function. This simple technique has saved me countless hours of troubleshooting! Another tip is to use a debugger, which allows you to pause your code’s execution and examine variables at specific points.

You’ll see the real power of functions and Jupyter Notebook when you apply them to real-world problems. For instance, at Dataquest, learners use Jupyter Notebook in our guided projects. Jupyter Notebook allows learners to document their thought process, share insights with other learners, and iterate on their analysis quickly.

If you’re excited to learn more about Python functions and Jupyter Notebook, I encourage you to check out our  Python Functions and Jupyter Notebook  course. It offers hands-on practice with real-world scenarios, helping you build the skills you need to tackle complex data analysis projects. You’ll learn how to write effective functions, use Jupyter Notebook efficiently, and apply these tools to solve practical problems.

Now that you’ve learned about the power of functions and Jupyter Notebook, it’s time to put them into practice. Start by applying them to a real-world problem, and don’t forget to share your progress with the Dataquest community.

Happy learning! Casey

What We're Reading

Give 20% Get $20

Now is the perfect time to share Dataquest with a friend. Gift a 20% discount, and for every friend who subscribes, earn a $20 bonus. Use your bonuses for digital gift cards, prepaid cards, or donate to charity. Your choice!  Click here

Community highlights

Project Spotlight

Sharing and reviewing others’ projects is one of the best things you can do to sharpen your skills. Twice a month we will share a project from the community. The top pick wins a $20 gift card!

This edition, we spotlight  Taribo Samuel Nyeduko ‘s project on  Indicators of Heavy Traffic on I-94  which stands out for its clearly stated goal, detailed and professionally-looking observations throughout the project, and an excellent, straight-to-the-point conclusion.

Decide on a path, set a specific time and place where you want to learn each day, and then show up. Over time you will get better by “just” showing up. But don’t be fooled, even carving out ten minutes a day is a lot tougher than you might think. Lisa Reiber Data Engineer at BMFSFJ – Startseite High-fives from Vik, Celeste, Casey, Anna P, Anna S, Anishta, Bruno, Elena, Mike, Daniel, and Brayan. The Real Power of Python Functions & Jupyter Notebook Want to write smarter code learn these 3 simple python concepts, why learn python next, learn faster and retain more. dataquest is the best way to learn. Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand OverflowAI GenAI features for Teams OverflowAPI Train & fine-tune LLMs Labs The future of collective knowledge sharing About the company Visit the blog Collectives™ on Stack Overflow Find centralized, trusted content and collaborate around the technologies you use most. Q&A for work Connect and share knowledge within a single location that is structured and easy to search. Get early access and see previews of new features. Shortcut key for presentation mode in Jupyter I'm trying to make presentation slides from Jupyter Notebook but there is no button to begin presentation mode. So, I'd like to know if there is any shortcut to start the presentation or any way to make that button appear. BTW, I use Python2.7 and already installed RISE. Thanks. jupyter-notebook 2 Answers 2 My issue was I tried to enable the "Enter RISE" button. So, to fix my issue, I used conda install -c damianavila82 rise instead of pip install RISE (I normally use pip to install new Python library, anyway). However, if you are looking for a shortcut for the presentation mode you can try "Atl + r" for entering and exiting RISE. I'm using Windows10, by the way. The conda way You can either install RISE with conda with as already mentioned in your own answer . This will install and set up Jupyter and RISE so that you can use RISE from Jupyter. The pip + jupyter-nbextension way Or you can install RISE with pip like you originally did and then make Jupyter aware of it with Apparently, the jupyter-nbextension install step copies the required JavaScript and CSS files from where pip placed them to where Jupyter can find them, while the jupyter-nbextension install step tells Jupyter to actually use them and RISE. Both ways (and a third one using the RISE source code repository) are documented at https://damianavila.github.io/RISE/installation.html Those who want to use pipenv to install RISE (or other Juypter extensions) may be interested in my question How should Jupyter extensions be installed and enabled for being reproducible? –  das-g Commented Feb 6, 2018 at 14:16 Your Answer Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more Sign up or log in Post as a guest. Required, but never shown By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy . Not the answer you're looking for? Browse other questions tagged jupyter-notebook reveal.js rise or ask your own question . The Overflow Blog Scaling systems to manage all the metadata ABOUT the data Navigating cities of code with Norris Numbers Featured on Meta We've made changes to our Terms of Service & Privacy Policy - July 2024 Bringing clarity to status tag usage on meta sites Tag hover experiment wrap-up and next steps Hot Network Questions Decent 900 MHz radome material from a hardware store "Not many can say that is there." Will I have to disclose traffic tickets to immigration (general) What was Jesus's relationship with God ("the father") before Jesus became a "begotten son"? Strategies for handling Maternity leave the last two weeks of the semester How do I loosen this nut of my toilet lid? Why did evolution fail to protect humans against sun? Relative pronouns that don't start the dependent clause Why is "a black belt in Judo" a metonym? What mode of transport is ideal for the cold post-apocalypse? Language inconsistency in The Expanse Story about fishing for a sea monster on Venus Why does editing '/etc/shells' file using 'sudo open' show an error saying I don't own the file? Looking for a British childrens book, I think from the 1950s, called "C-for-Charlie" Ripple counter from as few transistors as possible Would a manned Mars landing be possible with Apollo-era technology? A post-apocalyptic short story where very sick people from our future save people in our timeline that would be killed in plane crashes Functional derivative under a path integral sign Counter in Loop Unstable output C++: running the same thing twice gives different output Using "where" to modify people Is there a plurality of persons in the being of king Artaxerxes in his use of the pronoun "us" in Ezra 4:18? How can the Word be God and be with God simultaneously without creating the meaning of two Gods? What are these on my cabbages? Improving Quantum Developer Experience with Kubernetes and Jupyter Notebooks Quantum computing proposes a revolutionary paradigm that can radically transform numerous scientific and industrial application domains. To realize this promise, new capabilities need software solutions that are able to effectively harness its power. However, developers face significant challenges when developing quantum software due to the high computational demands of simulating quantum computers on classical systems. In this paper, we investigate the potential of using an accessible and cost-efficient manner remote computational capabilities to improve the experience of quantum software developers. Index Terms: I introduction. Quantum computing holds great promise as a revolutionary technology that can transform various scientific and industry fields. By harnessing the principles of quantum mechanics, quantum computers can perform complex calculations and solve problems that are currently intractable for classical computers. This promises breakthroughs in areas such as cryptography, optimization, drug discovery, materials science, or machine learning. Although quantum advantage has been declared in experiments where quantum computing hardware has shown to provide a significant computational advantage over classical alternatives in specific problems  [ 1 ] , we still have to work for the foreseeable future with Noisy Intermediate-Scale Quantum (NISQ) computers. These computers employ a hybrid computational model in which a classical computer controls a noisy quantum device. Even as NISQ devices are not capable of providing the quantum advantage promised by quantum algorithms  [ 2 ] , they are an invaluable platform for research and experimentation. However, even with the steady advancements in terms of qubit counts  [ 3 , 4 ] , current NISQ computers are out of reach of most developers due to their scarcity and high operational costs. Therefore, quantum software developers have to rely on simulators running on classical computers to experiment with quantum software. While it is straightforward to start the development process on commonly used hardware, running larger circuits necessitates specialized graphical processing units (GPU) that are found in high-end consumer products (e.g. mobile workstations) or high-performance computing infrastructure (e.g. clusters of GPUs). Therefore, a developer would require either deep technical knowledge to configure the software stack required for using the advanced GPU capabilities to be able to run circuits up to 31 qubits  [ 5 ] , or access to a supercomputer for running circuits with 40 qubits  [ 6 ] . Our approach to improve the quantum software development experience is to execute the quantum software routines on Qubernetes clusters [ 7 ] , which manage the necessary computational resources. The solution is packaged as an easy-to-use Jupyter kernel, therefore the developers are not directly exposed to the complexities of operating the cluster where the quantum routines are executed, allowing them to switch between the local and the remote development environments when the number of qubits in the quantum circuits become large. The rest of the paper is organised as follows. Section  II presents the background and motivation behind this work. Section  III describes the implementation of the solution. Section  IV describes the test environments and discusses the performance. Concluding remarks and future work are presented in Section  V . II Background and motivation II-A Software development life cycle The software development life cycle (SDLC) of hybrid classic-quantum applications consists of a multi-faceted approach [ 8 ] , as depicted in Figure  1 . At the top level, the classical software development process starts by identifying user needs and deriving them into system requirements. These requirements are transformed into a design and implemented. The result is verified against the requirements and validated against user needs. Once the software system enters the operational phase, any detected anomalies are used to identify potential new system requirements, if necessary. A dedicated track for quantum components is followed within the SDLC  [ 9 ] , specific to the implementation of quantum technology. The requirements for these components are converted into a design, which is subsequently implemented on classic computers, verified on simulators or real quantum hardware, and integrated into the larger software system. During the operational phase, the quantum software components are executed on actual quantum hardware. The scheduling ensures efficient utilization of the scarce quantum hardware resources, while monitoring capabilities enable the detection of anomalies throughout the operational stage. As quantum computers are a scarce resource, it is not practical to develop quantum software components directly on hardware. Instead, developers should use simulators that use commonly available and less expensive classical resources (e.g., CPUs and GPUs  [ 10 ] ), for the early stages of development and testing. Later on, they can use more sophisticated simulators that are able to simulate the noise of actual hardware. Only when the components are mature enough the development can be continued on quantum processing units (QPU), the actual hardware that will be used during the execution phase. However, as the implementation of quantum software stack trades off the visibility of the execution process for usability [ 11 ] , developers have to experiment and iterate on devices and simulators to determine the actual behaviour of their programs. This approach ensures that the use of quantum resources is efficient and effective. II-B Quantum development toolkits and simulators Qiskit is a Python library and a quantum development toolkit designed to accommodate different types of Quantum Computers in NISQ era. It allows algorithm designers develop applications leveraging quantum computing, circuit designers to optimize cirquits and explore its properties like error correction, verification and validation. Qiskit offers also tools to research and optimize gates, with precise control and ability to explore noise, apply dynamical decoupling and perform optimized control theory. Qiskit is an open-source project and currently offers dozens of additional libraries, plugins, simulator backends, application packages for multiple domains such as machine learning, physics, chemistry and finance and other related projects available. In Qiskit there are also several transpiler plugins available for users to optimize and interact with the transpiling process 1 1 1 https://qiskit.github.io/ecosystem/ . Among Qiskit, IBM offers OpenQASM and OpenPulse. OpenQASM is an imperative language whose main purpose is to act as an intermediate representation for high-level compilers for QC hardware. It offers precise control over gates, measurement and conditionals 2 2 2 https://openqasm.com/intro.html . OpenPulse is a specification for pulse-level control, for general-purpose QC and it is designed to be hardware architecture agnostic and enable experimentation with a higher level of control [ 12 ] . Qiskit Aer 3 3 3 https://qiskit.github.io/qiskit-aer/index.html is Qiskit library with high-performance QC simulators and noise models. Some simulators included in Aer have support for leveraging Nvidia CPUs with Cuda version 11.2 or newer. Qiskit, Qiskit Aer and Cuda relations in the development and execution environment are presented in Figure 2 PennyLane 4 4 4 https://pennylane.ai/ is a Python library specialized in machine learning for quantum computing by enabling the use of popular, commonly used classical machine learning frameworks, like TensorFlow 5 5 5 https://www.tensorflow.org/ . PennyLane is designed to support various executions with variable QC simulators and actual QC hardware, handling the communication with the device and compiling the circuits. The library includes a basic simulator backend and has GPU enabling PennyLane Lightning 6 6 6 https://docs.pennylane.ai/projects/lightning/ plugin with three different high-performance backends. Lightning GPU uses NVIDIA cuQuantum SDK to enable accelerating the simulation of quantum state vectors, it supports CUDA-capable Nvidia GPUs. Nvidia CUDA 7 7 7 https://developer.nvidia.com/cuda-zone is a computing platform developed for GPUs, for computationally demanding tasks suitable for parallel computing with up to thousands of threads. cuQuantum 8 8 8 https://docs.nvidia.com/cuda/cuquantum/ is an SDK based on CUDA, offering libraries for Quantum computing, with two libraries, cuStateVec for state vector computation and cuTensorNet for tensor network computation. cuStateVec is used by gate-based general quantum computer simulators, providing measurement, gate application, expectation value, sampler and state vector movement. CuStateVec library is available for Cuda versions 11 and 12. Nvidia cuQuantum is used by both PennyLane Lightning and Qiskit Aer, for their GPU-powered quantum simulator backends. Developing across all target execution environments exposes the quantum software developer to a wide range of technologies that force them to balance their primary development activities with deep dives into operational aspects like configuring and maintaining their development environments or getting access to compatible hardware accelerators for running the relevant simulators. For example, Fig. 2 provides an overview of the software stack that application or algorithm developers using the Qiskit tools must to be aware of. The situation is similar for other mainstream toolkits like PennyLane or Cirq 9 9 9 https://quantumai.google/qsim/cirq_interface . Experimental programming toolkits like Eclipse Qrips [ 13 ] , leverage the existing Cirq or Qiskit assets to be able to execute circuits on GPU-accelerated simulators. II-C Notebooks JupyterLab 10 10 10 https://jupyter.org offers a versatile and user-friendly interactive computing platform suitable for data science, scientific computing, machine learning, and quantum computing. With its flexible architecture and extensive plugin ecosystem, it allows its users to develop customized workflows tailored to their specific needs, such as data exploration, prototyping algorithms or creating interactive presentations. The key enabler of Jupyter is the notebook, an interactive and collaborative document formed by a collection of cells that can contain code, Markdown 11 11 11 https://spec.commonmark.org/current/ formatted text, equations or interactive widgets. A kernel is a computational engine that executes the code contained within the notebook. Jupyter supports multiple programming languages through different kernels, such as Python, R, Julia, and others. Users can select the desired kernel depending on their preferred programming language for a specific notebook. These combined capabilities allow scientists and algorithm developers to perform their work using a combination of code, explanatory text, and visualizations, making it easier to experiment, iterate, and document the development process. JupyterHub 12 12 12 https://jupyter.org/hub expands the functionality of JupyterLab to groups of users, giving them access to computational environments and resources without the burden of installation and maintenance tasks. The project provides two distributions: The Littlest JupyterHub – suitable for small group of users, typically less than 100, can be installed on a single virtual machine, and Zero to JupyterHub for Kubernetes 13 13 13 https://z2jh.jupyter.org/en/latest/index.html – suitable for large number of user, makes extensive use of container technologies, cloud resources and infrastructure. The container that runs JupyterLab can be customised following the Jupyter Docker Stacks 14 14 14 https://jupyter-docker-stacks.readthedocs.io/en/latest/index.html convention, allowing the user to run quantum algorithms in GPU accelerated simulators like Qiskit Aer or PennyLane Lightning. However, as the pod life cycle is linked to the user session, the GPU is locked by the user’s pod regardless if the Python kernel executes code or not, a utilization pattern that is not optimal. II-D Computing at-scale paradigms Cloud computing allows the development of scalable applications  [ 14 ] , which rely on computing resources like computing power, storage and databases that are accessed on a pay-per-use basis. Through the extensive use of application programming interfaces (APIs), teams formed of software developers and operators can scale these resources up and down in response of the users’ needs. This entails designing applications as small, loosely coupled components that can be bundled with their dependencies into portable containers and deployed on the immutable infrastructure. Furthermore, integrated monitoring and logging offer valuable insights into performance, health, and behaviour, empowering a swift response to potential anomalies. Kubernetes is the industry-standard container orchestration platform for automating deployment, scaling, and management of containerized cloud-native applications. Developed as an open-source solution by Cloud Native Computing Foundation (CNCF) 15 15 15 https://www.cncf.io/ , together with the myriad of projects that offers supporting functionality, it allows users to deploy applications on the managed infrastructure of the major cloud providers (e.g., AWS EKS 16 16 16 https://aws.amazon.com/eks/ , Azure AKS 17 17 17 https://azure.microsoft.com/en-us/products/kubernetes-service , or GCP GKE 18 18 18 https://cloud.google.com/kubernetes-engine ), smaller or regional cloud providers, or on-prem – using own infrastructure. Qubernetes [ 7 ] (or Kubernetes for Quantum) exposes the quantum computation concepts like tasks and hardware capabilities following established cloud-native principles, as Kubernetes jobs and quantum-capable nodes. Following this conventions, allows the seamless integration of quantum computing into the larger Kubernetes ecosystem. High-performance computing (HPC) relies on using supercomputers and parallel processing techniques to solve complex computational problems quickly and efficiently, in application domains that require massive computational power  [ 15 ] . HPC systems typically consist of multiple interconnected processors or nodes that work together to execute tasks in parallel, enabling large-scale simulations, data analysis, and scientific computations, leveraging the Open Message Passing Interface (OpenMPI 19 19 19 https://www.open-mpi.org ) compatible architectures. Quantum computing enables the existing base of cloud-native and HPC applications to accelerate appropriate computational tasks. Two notable approaches for integrating the two software stacks are HPC-QC  [ 16 ] , which uses the OpenMPI, and XACC  [ 17 ] approach based on the OSGi 20 20 20 https://www.osgi.org architecture. Similarly, Qiskit’s quantum-serverless  [ 18 ] proposes a cloud-based approach for running hybrid classical-quantum programs. The proposed programming model, conforming to the RAY 21 21 21 https://www.ray.io computing framework, makes it easy to scale Python workloads on a Kubernetes cluster in which the quantum execution environment is represented by a distributed Qiskit runtime that allows transparent access to multiple QPUs. Despite all these efforts, the integration of quantum computing into classical paradigms is fragmented. The EuroHPC aims to address this with the Universal Quantum Access   [ 19 ] development. III The Jupyter kernel for Qubernetes Iii-a system architecture and components. The solution enables a quantum software developer to run quantum routines or programs using GPU-accelerated simulators (e.g. Qiskit Aer or Pennylane Lightning) on a Qubernetes cluster with better computational resources compared to their personal laptop. The solution involves a custom Jupyter kernel 22 22 22 https://github.com/torqs-project/q8s-kernel (e.g., q8s_kernel ), and a compatible cluster that has at least one quantum capable node that allows the execution of GPU-accelerated containers via the Nvidia Container Toolkit 23 23 23 https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/index.html . To utilize the solution, the developer must install the kernel and specify the location of the configuration file of the cluster (e.g., kubeconfig 24 24 24 https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/ ) as an environment variable. Through the user interface of the Jupyter Notebook/Lab, the user can switch between the local development kernel (e.g. IPython ) and the remote Qubernetes cluster. The system architecture and components are detailed in Fig.  4 . III-B Task execution model [t] {minted} [fontsize= ,xleftmargin=1em,linenos=true,highlightlines=12-13,16,19,23]yaml apiVersion: batch/v1 kind: Job metadata: name: ”quantum-job” spec: template: metadata: name: ”quantum-pod” spec: containers: - name: ”quantum-task” image: registry.com/user/job-dependencies:v1 command: [”python”, ”/app/main.py”] resources: requests: nvidia.com/gpu: ’1’ # requires GPU usage volumeMounts: - name: config-volume mountPath: /app volumes: - name: config-volume configMap: name: task-files #”main.py”: ”code” restartPolicy: Never Quantum job specification The execution flow is triggered by the user pressing the run button in the notebook. When the kernel receives the do_execute command, it detects the dependencies in the cell code and prepares the container specification (e.g., Dockerfile and requirements.txt ), using as base a pre-build image that includes all dependencies for the CUDA version supported in the cluster. The kernel builds the image and pushes it to the container registry. Then it creates a Kubernetes Job specification that corresponds to the execution task (see Listing 5 ), and a ConfigMap that contains the actual code that will be mounted as a volume in the Pod. Once the cluster API server receives the request, it schedules the job when the requested GPU resources are available. The Pod pulls the image from the Registry and executes the tasks. The kernel polls the API server for the Job’s status waiting for completion, then collects the logs and cleans up, by deleting the Job and the ConfigMap. Depending on the container’s exit code (e.g. success for 0, or failure otherwise), the kernel returns the result to the notebook on the stdout or stderr respectively. The kernel rebuilds the image and the pod pulls the image only when the dependencies change. The task execution sequence is depicted in Fig. 5 . IV Discussion In this section, we introduce the test scenarios and evaluate the use of the custom Jupyter kernel from the ease of use and cost effectiveness perspectives. Scenario Hardware category Model/Provider CPU GPU (CUDA compatible) Baseline Business laptop Dell Latitude 7440 Intel i5-1345U 16GB - Mobile workstation Mobile workstation Dell Precision 7680 Intel i9-13950HX 64GB Nvidia GeForce RTX 4090 Laptop 16 GB Cloud GPU Cloud server puzl.cloud 2 vCPUs up to 64GB Nvidia A100 40GB We have tested the Jupyter kernel for Qubernetes in the following scenarios that we consider representative of how it will be used. The baseline consists of the user running the development environment (e.g. the Jupyter Notebook/Lab) and executing the quantum routine on his own laptop. The following test scenarios employ CUDA capable GPUs accessed remotely in Qubernetes clusters: Cluster with mobile workstation - Users with better hardware share their computational resources (e.g. a mobile workstation) with the rest of the team. The users run the development environment similar to the baseline scenario, but the quantum routines are executed on the mobile workstation. Cluster with cloud GPUs - The user runs the development environment on his own laptop and executes the quantum routine experiments on a Qubernetes cluster operated by a commercial entity. In our case, we have selected Puzl 25 25 25 https://puzl.cloud/ , a provider that offers access to Nvidia A100 40GB GPUs. The cost of using the GPU resources is approximately 1.6 EUR/h, in line with other cloud infrastructure providers. The charging model is based on effective utilization of the GPU resource, e.g., the effective time the Job runs to completion. The cluster is shared with the other Puzl users that execute their own workloads while our quantum routines are executed. The detailed hardware configurations of the devices used in the test scenarios are described in Table  I . Ease of use - The solution is perceived by the user as a standard Jupyter kernel, see Fig. 6 . To function properly, the implementation relies on Docker and Kubernetes, widely used tools supported on a multitude of operating systems. The selection of the cluster where the quantum task execution is performed is achieved by providing the kubeconfig configuration file as an environment variable. The solution does not require a deep understanding of Kubernetes cluster management beyond the configuration file. As such the user is not exposed to the complexities of enabling access to the GPUs or configuring the computational layer of the CUDA, cuQauntum. Cost effectiveness - The GPU resources available in the cluster are used only while the quantum accelerated job is executed. This behaviour allows the GPU resource of the mobile workstation to be used by other users of the cluster, maximizing its utilization of resources already acquired by the organization. Similarly, as the cloud GPU resource is charged per use, releasing the resource minimizes the cost. As such, the Jupyter kernel for Qubernetes increases the utilization in a cost efficient manner of the GPU resources, comparing with the standard JupyterHub on Kubernetes approach. V Conclusion and future work This paper explores the potential of using remote computational resources available in Qubernetes clusters to enhance the experience of quantum software developers across three key aspects: execution speedups, ease of use and cost-effectiveness. To achieve this objective we have developed a custom Jupyter kernel that packages the notebook cells as Kubernetes jobs and executes them on clusters that have advanced CUDA computing capabilities. Moving forward, we plan to extend this functionality to other development environments beyond notebooks. Acknowledgements This work has been supported by the Academy of Finland (project DEQSE 349945) and Business Finland (project TORQS 8582/31/2022). [1] B. C. Sanders, “Quantum leap for quantum primacy,” Physics , vol. 14, p. 147, 2021. [2] S. Chen, J. Cotler, H.-Y. Huang, and J. Li, “The complexity of nisq,” Nature Communications , vol. 14, no. 1, p. 6001, Sep 2023. [Online]. Available: https://doi.org/10.1038/s41467-023-41217-6 [3] J. Preskill, “Quantum computing 40 years later,” 2023. [Online]. Available: https://doi.org/10.48550/arXiv.2106.10522 [4] S. S. Gill, A. Kumar, H. Singh, M. Singh, K. Kaur, M. Usman, and R. Buyya, “Quantum computing: A taxonomy, systematic review and future directions,” Software: Practice and Experience , vol. 52, no. 1, pp. 66–114, 2022. [Online]. Available: https://doi.org/10.1002/spe.3039 [5] J. Faj, I. Peng, J. Wahlgren, and S. Markidis, “Quantum computer simulations at warp speed: Assessing the impact of gpu acceleration: A case study with ibm qiskit aer, nvidia thrust & cuquantum,” in 2023 IEEE 19th International Conference on e-Science (e-Science) .   Los Alamitos, CA, USA: IEEE Computer Society, oct 2023, pp. 1–10. [Online]. Available: https://doi.org/10.1109/e-Science58273.2023.10254803 [6] D. Willsch, M. Willsch, F. Jin, K. Michielsen, and H. De Raedt, “Gpu-accelerated simulations of quantum annealing and the quantum approximate optimization algorithm,” Computer Physics Communications , vol. 278, p. 108411, 2022. [Online]. Available: https://www.sciencedirect.com/science/article/pii/S0010465522001308 [7] V. Stirbu, O. Kinanen, M. Haghparast, and T. Mikkonen, “Qubernetes: Towards a unified cloud-native execution platform for hybrid classic-quantum computing,” Information and Software Technology , inpress. [8] V. Stirbu, M. Haghparast, M. Waseem, N. Dayama, and T. Mikkonen, “Full-stack quantum software in practice: ecosystem, stakeholders and challenges,” in 2023 IEEE International Conference on Quantum Computing and Engineering (QCE) , vol. 2.   IEEE, 2023, pp. 177–180. [Online]. Available: https://doi.org/10.1109/QCE57702.2023.10205 [9] B. Weder, J. Barzen, F. Leymann, and D. Vietz, Quantum Software Development Lifecycle .   Cham: Springer International Publishing, 2022, pp. 61–83. [Online]. Available: https://doi.org/10.1007/978-3-031-05324-5_4 [10] E. Gutiérrez, S. Romero, M. A. Trenas, and E. L. Zapata, “Quantum computer simulation using the cuda programming model,” Computer Physics Communications , vol. 181, no. 2, pp. 283–300, 2010. [Online]. Available: https://doi.org/10.1016/j.cpc.2009.09.021 [11] V. Stirbu, A. Meijer-van de Griend, and J. Muff, “Exposing the hidden layers and interplay in the quantum software stack,” in 2024 IEEE International Conference on Software Architecture .   IEEE, 2024. [Online]. Available: https://doi.org/10.48550/arXiv.2403.16545 [12] D. C. McKay, T. Alexander, L. Bello, M. J. Biercuk, L. Bishop, J. Chen, J. M. Chow, A. D. Córcoles, D. Egger, S. Filipp et al. , “Qiskit backend specifications for openqasm and openpulse experiments,” 2018. [Online]. Available: https://doi.org/10.48550/arXiv.1809.03452 [13] R. Seidel, N. Tcholtchev, S. Bock, and M. Hauswirth, “Uncomputation in the qrisp high-level quantum programming framework,” in Reversible Computation , M. Kutrib and U. Meyer, Eds.   Cham: Springer Nature Switzerland, 2023, pp. 150–165. [Online]. Available: https://doi.org/10.1007/978-3-031-38100-3_11 [14] D. Gannon, R. Barga, and N. Sundaresan, “Cloud-native applications,” IEEE Cloud Computing , vol. 4, no. 5, pp. 16–21, Sep. 2017. [Online]. Available: https://doi.org/10.1109/MCC.2017.4250939 [15] T. Sterling, M. Brodowicz, and M. Anderson, High performance computing: modern systems and practices .   Morgan Kaufmann, 2017. [16] M. Schulz, M. Ruefenacht, D. Kranzlmuller, and L. Schulz, “Accelerating hpc with quantum computing: It is a software challenge too,” Computing in Science & Engineering , vol. 24, no. 04, pp. 60–64, jul 2022. [Online]. Available: https://doi.org/10.1109/MCSE.2022.3221845 [17] A. J. McCaskey, D. I. Lyakh, E. F. Dumitrescu, S. S. Powers, and T. S. Humble, “Xacc: a system-level software infrastructure for heterogeneous quantum–classical computing*,” Quantum Science and Technology , vol. 5, no. 2, p. 024002, feb 2020. [Online]. Available: https://dx.doi.org/10.1088/2058-9565/ab6bf6 [18] I. Faro, I. Sitdikov, D. Valinas, F. Fernandez, C. Codella, and J. Glick, “Middleware for quantum: An orchestration of hybrid quantum-classical systems,” in 2023 IEEE International Conference on Quantum Software (QSW) .   Los Alamitos, CA, USA: IEEE Computer Society, jul 2023, pp. 1–8. [Online]. Available: https://doi.ieeecomputersociety.org/10.1109/QSW59989.2023.00011 [19] EuroHPC Joint Undertaking, Decision Of The Governing Board Of The EuroHPC Joint Undertaking No 44/2023, Adopting the Joint Undertaking’s Work Programme and Budget for the year 2024 , 12 2023. [Online]. Available: https://eurohpc-ju.europa.eu/system/files/2023-12/Decision%2044.2023.-%20WP%202024%20FINAL_.pdf 281 IMAGES Create Presentation from Jupyter Notebook 5 Slides for Tips on Presentation Mode in Jupyter Notebook How to Create Presentation Slides from Jupyter Notebooks Presenting Code Using Jupyter Notebook Slides Create Presentation from Jupyter Notebook how to make a presentation in jupyter notebook COMMENTS Creating Presentations with Jupyter Notebook RISE also works with Notebook widgets. Try creating a new cell with the following code: from ipywidgets import interact. def my_function(x): return x. # create a slider. interact(my_function, x=20) Now start the slideshow on that cell and try running the cell (SHIFT+ENTER). You should see something like this: Presenting Code Using Jupyter Notebook Slides 2.1K. 12. When you make a slide presentation, there are a few programs you likely think of: Microsoft PowerPoint, Google Slides, Prezi (just kidding). PPT and Slides are great applications, to be ... Present Your Data Science Projects with Jupyter Notebook Slides! Remember that in Jupyter Notebook cells are the units containing code and markdown. There are 5 options for each cell. Slide, Sub-slide, fragment, skip and notes. 5 Slides for Tips on Presentation Mode in Jupyter Notebook This is an alternative to copy-and-pasting screen captures into other presentation software. The first step is to enable the Slideshow option in the View > Cell Toolbar options. Just click on the Slideshow option and continue reading. Enable Slideshow. Each cell in the Jupyter Notebook will now have a Slide Type option in the upper-right corner. Create Presentation from Jupyter Notebook Jupyter Notebook Presentations might be a great alternative to traditional presentation software. You will save time by building the presentation in the same environment where your code is. Any update in code or chart change will immediately affect the presentation - no need to manually copy-paste results. ... Presenting Data Using Jupyter Notebook Slides (VS Code) Open Jupyter Notebook in VS Code. In order to set your code blocks as slides, right-click the bottom of the code block and select "Switch Slide Type". Switch Slide Type. Next, we can select ... Creating Interactive Slideshows in Jupyter Notebooks One of them is "Jupyter's built-in slideshow feature". To create interactive slideshows in Jupyter Notebook with the help of its built-in feature, perform the following steps: Step 1: Open a New Notebook. To start with, open a new notebook and rename it. Step 2: Create new Slides. Create interactive slides with Python in 8 Jupyter Notebook cells Creating presentations in Jupyter Notebook is a great alternative to manually updating slides in other presentation creation software. If your data changes, you just re-execute the cell and slide chart is updated. Jupyter Notebook is using Reveal.js (opens in a new tab) for creating slides from cells. The standard approach is to write slides ... Turn your Jupyter Notebook into interactive Presentation Slides using After configured each cell in Jupyter Notebook using Anaconda, you can now follow the steps in the previous section "Convert ipynb file to HTML file" to turn your Jupyter Notebook into interactive HTML Presentation Slides. The generated output is a single HTML file, making it incredibly convenient to share and save on a USB drive. Presenting with Jupyter Notebooks :: Scott Jeen The best way to walk through this tutorial is using the accompanying Jupyter Notebook: [Jupyter Notebook] - In the last year I've started presenting work using Jupyter Notebooks, rebelling against the Bill Gates'-driven status-quo. Here I'll explain how to do it. It's not difficult, but in my opinion makes presentations look slicker, whilst allowing you to run code live in a presentation ... Create a slide deck using Jupyter Notebooks Using Jupyter Notebooks for presentations. I begin my presentations by using Markdown and code blocks in a Jupyter Notebook, just like I would for anything else in JupyterLab. I write out my presentation using separate Markdown sections for the text I want to show on the slides and for the speaker notes. Code snippets go into their own blocks ... Creating Slides with Jupyter Notebook This will run a server which opens the presentation in your browser ready for presentation. Another neat thing is RISE, a Jupyter slideshow extension that allows you to instantly turn your Jupyter Notebooks into a slideshow with the press of a button in your notebook:. Export as PDF. Finally, if you want to create a PDF from your slides, you can do that by adding ?print-pdf to the url of the ... Creating presentations from Jupyter notebooks Creating presentations from Jupyter notebooks. January 12, 2022 . 2022 · python jupyter data visualization The Jupyter notebook, controversial though it may be, is a core data exploration and experimentation platform for many in the data and scientific communities. In particular, its combination of REPL-like input and embedded HTML output make ... Using a Jupyter notebook to make presentation slides The process I followed to create the slides is very simple. Open a blank Jupyter notebook. Add a cell and convert it to Markdown (either esc + m) or by using the drop down menu at the top of the notebook. Add your text, equation or image to the cell (images can be added via the edit menu, though some HTML tags may be needed to render and/or ... Create Presentations Using RISE in Jupyter Notebook Let's start with the basics. Installing RISE is the first step towards creating engaging presentations in Jupyter Notebook. To install RISE, follow these simple steps: Open your terminal, use the following command, and press shift+enter to execute the command: python -m pip install RISE. Creating a Presentation with Jupyter Notebook and RISE (Video) In this tutorial, you will learn how to use Jupyter Notebooks to create slide show presentations. This allows you to run and edit live code in your slides. If playback doesn't begin shortly, try restarting your device. Videos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to ... How to Create Presentations Using RISE in Jupyter Notebook RISE is a Jupyter Notebook extension that allows you to easily create reveal.js-based presentations from Jupyter Notebook. RISE is a relatively powerful tool with a lot of in-built functionality, which is also simple enough to be used by beginners. That being said, ... Creating an Interactive Presentation with Jupyter Notebook and Plotly In Jupyter Notebook, each cell can play a part in the presentation slides. To set the role each cell play, you have to change the cell toolbar view by View -> Cell Toolbar -> Slideshow. Changing the view will allow you to set what type of slides you want for each cell. There are 5 Slide Types you can select: Slide. How to create data-driven presentations with jupyter notebooks, reveal We could use jupyter notebook itself to create a reveal.js set of slide decks, but exporting first to markdown provides you more control on some aspects of the elements o slide creation. You use the following code to convert a jupyter notebook to a markdown document: ~$ jupyter nbconvert -t markdown mynotebook.ipynb (1) # generates mynotebook ... Creating Presentations With Jupyter Notebook Next you will need to run the following command: 1. 1. jupyter nbconvert slideshow.ipynb --to slides --post serve. Running the slideshow. To navigate your slideshow, you can use your left and ... python In Jupyter Notebook we could create slides, like explained here. Here you can see a reproducible example to create Jupyter notebook slides via Anaconda-navigator: ... After assigning slide types to your cells, create an HTML slideshow presentation by opening the integrated terminal and running the command, jupyter nbconvert '<notebook-file-name ... The Real Power of Python Functions & Jupyter Notebook Jupyter Notebook is ideal for data analysis because it allows you to mix code with explanatory text, making your analysis easy to follow and share with others. You can also run code cells independently, which is great for iterative development and experimentation. Plus, you can easily create visualizations right in the notebook, helping you ... Run Jupyter cells in slideshow mode 32. You can display a Jupyter notebook in an active html setting by running : $ jupyter nbconvert untitled.ipynb --to slides --post serve. Is there any ways to run a notebook in the same slideshow format in order to allow for a live presentation/execution of your cells ? slideshow. jupyter. Shortcut key for presentation mode in Jupyter 2. My issue was I tried to enable the "Enter RISE" button. So, to fix my issue, I used conda install -c damianavila82 rise instead of pip install RISE (I normally use pip to install new Python library, anyway). However, if you are looking for a shortcut for the presentation mode you can try "Atl + r" for entering and exiting RISE. Improving Quantum Developer Experience with Kubernetes and Jupyter Quantum software, software development, developer experience, Jupyter notebook I Introduction. ... prototyping algorithms or creating interactive presentations. The key enabler of Jupyter is the notebook, an interactive and collaborative document formed by a collection of cells that can contain code, ... assignment essay homework paper phd report resume review speech thesis