Fixed icon issue in #336 using fontawesome package

Author: ttimbers

jupyter.Rmd

@@ -4,6 +4,7 @@
 library(magick)
 library(magrittr)
 library(knitr)
+library(fontawesome)
 
 knitr::opts_chunk$set(message = FALSE, 
                       fig.align = "center")
@@ -102,7 +103,7 @@ process.
 To run the a code cell independently, the cell needs to first be activated. This
 is done by clicking on it with the cursor. Jupyter will indicate a cell has been
 activated by highlighting it with a blue rectangle to its left. After the cell
-has been activated (Figure \@ref(fig:activate-and-run-button)), the cell can be run by either pressing the **Run** ($\blacktriangleright$) 
+has been activated (Figure \@ref(fig:activate-and-run-button)), the cell can be run by either pressing the **Run** (`r fa("play", height = "11px")`) 
 button in the toolbar, or by using a keyboard shortcut of 
 `Shift + Enter`.
 
@@ -117,7 +118,7 @@ To execute all of the code cells in an entire notebook, you have three options:
 
 2. Select **Kernel** >> **Restart Kernel and Run All Cells...** from the menu (Figure \@ref(fig:restart-kernel-run-all)).
 
-3. Click the ($\blacktriangleright\blacktriangleright$) button in the tool bar.
+3. Click the (`r fa("fast-forward", height = "11px")`) button in the tool bar.
 
 All of these commands result in all of the code cells in a notebook being run.
 However, there is a slight difference between them.  In particular, only
@@ -139,8 +140,8 @@ outputs the results. Kernels for many different programming languages have
 been created for Jupyter, which means that Jupyter can interpret and execute 
 the code of many different programming languages. To run R code, your notebook 
 will need an R kernel. In the top right of your window, you can see a circle 
-that indicates the status of your kernel. If the circle is empty ($\bigcirc$), 
-the kernel is idle and ready to execute code. If the circle is filled in ($\bullet$), 
+that indicates the status of your kernel. If the circle is empty (`r fa("circle", fill = "white", stroke = "black", stroke_width = "10px", height = "11px")`), 
+the kernel is idle and ready to execute code. If the circle is filled in (`r fa("circle", fill = "black", stroke = "black", stroke_width = "10px", height = "12px")`), 
 the kernel is busy running some code.
 
 You may run into problems where your kernel \index{kernel!interrupt,restart} is stuck for an excessive amount 
@@ -181,7 +182,7 @@ To edit a Markdown cell in Jupyter, you need to double click on the cell. Once
 you do this,  the unformatted (or *unrendered*) version of the text will be
 shown (Figure \@ref(fig:markdown-cell-not-run)). You 
 can then use your keyboard to edit the text. To view the formatted
-(or *rendered*) text (Figure \@ref(fig:markdown-cell-run)), click the **Run** ($\blacktriangleright$) button in the toolbar, 
+(or *rendered*) text (Figure \@ref(fig:markdown-cell-run)), click the **Run** (`r fa("play", height = "11px")`) button in the toolbar, 
 or use the `Shift + Enter` keyboard shortcut.
 
 ```{r markdown-cell-not-run, echo = FALSE, fig.cap = "A Markdown cell in Jupyter that has not yet been rendered and can be edited.", fig.retina = 2, out.width="100%"}
@@ -201,7 +202,7 @@ By default, all new cells in Jupyter start as code cells, so
 the cell format needs to be changed to be recognized and rendered as a Markdown 
 cell. To do this, click on the cell with your cursor to 
 ensure it is activated.  Then click on the drop-down box on the toolbar that says "Code" (it
-is next to the $\blacktriangleright\blacktriangleright$ button), and change it from "**Code**" to "**Markdown**" (Figure \@ref(fig:convert-to-markdown-cell)).
+is next to the `r fa("fast-forward", height = "11px")` button), and change it from "**Code**" to "**Markdown**" (Figure \@ref(fig:convert-to-markdown-cell)).
 
 ```{r convert-to-markdown-cell, echo = FALSE, fig.cap = "New cells are by default code cells. To create Markdown cells, the cell format must be changed.", fig.retina = 2, out.width="100%"}
 image_read("img/convert-to-markdown-cell.png") |> 
@@ -226,7 +227,7 @@ As you might know (or at least imagine) by now, Jupyter notebooks are great for
 interactively editing, writing and running R code; this is what they were 
 designed for! Consequently, Jupyter notebooks are flexible in regards to code 
 cell execution order. This flexibility means that code cells can be run in any 
-arbitrary order using the **Run** ($\blacktriangleright$) button. But this flexibility has a downside: 
+arbitrary order using the **Run** (`r fa("play", height = "11px")`) button. But this flexibility has a downside: 
 it can lead to Jupyter notebooks whose code cannot be executed in a linear 
 order (from top to bottom of the notebook). A nonlinear notebook is problematic 
 because a linear order is the conventional way code documents are run, and 
@@ -235,7 +236,7 @@ code is used in some automated process, it will need to run in a linear order,
 from top to bottom of the notebook. \index{Jupyter notebook!best practices}
 
 The most common way to inadvertently create a nonlinear notebook is to rely solely 
-on using the $\blacktriangleright$ button to execute cells. For example, 
+on using the `r fa("play", height = "11px")` button to execute cells. For example, 
 suppose you write some R code that creates an R object, say a variable named 
 `y`. When you execute that cell and create `y`, it will continue 
 to exist until it is deliberately deleted with R code, or when the Jupyter 
@@ -288,7 +289,7 @@ We recommend as a best practice to run the entire notebook in a fresh R session
 at least 2-3 times within any period of work. Note that,
 critically, you *must do this in a fresh R session* by restarting your kernel.
 We recommend using either the **Kernel** >> 
-**Restart Kernel and Run All Cells...** command from the menu or the $\blacktriangleright\blacktriangleright$ 
+**Restart Kernel and Run All Cells...** command from the menu or the `r fa("fast-forward", height = "11px")` 
 button in the toolbar. Note that the **Run** >> **Run All Cells** 
 menu item will not restart the kernel, and so it is not sufficient 
 to guard against these errors.
@@ -327,7 +328,7 @@ their computer to run the analysis successfully.
 
 2. As you write code in a Jupyter notebook, run the notebook in a linear order 
 and in its entirety often (2-3 times every work session) via the **Kernel** >> 
-**Restart Kernel and Run All Cells...** command from the Jupyter menu or the $\blacktriangleright\blacktriangleright$ 
+**Restart Kernel and Run All Cells...** command from the Jupyter menu or the `r fa("fast-forward", height = "11px")` 
 button in the toolbar.
 
 3. Write the code that loads external R packages near the top of the Jupyter