j1-template 2022.2.2 → 2022.3.1

data/lib/starter_web/pages/public/jupyter/docs/j1-nbinteract-doc.adoc

@@ -1,6 +1,6 @@
 ---
 title:                                  J1 NBI
-tagline:                                textbook integration
+tagline:                                jupyter notebook integration
 date:                                   2022-04-17 00:00:00
 description: >
                                         The package nbinteract aims to enable authors and educators to create and
@@ -60,11 +60,12 @@ resource_options:
 
 // Set (local) page attributes here
 // -----------------------------------------------------------------------------
-// :page--attr:                                   <attr-value>
-:binder-badges-enabled:                           true
-:binder--home:                                    https://mybinder.org/
-:binder--docs:                                    https://mybinder.readthedocs.io/en/latest/
-:binder-app-launch--tree:                         https://mybinder.org/v2/gh/jekyll-one/nbinteract-notebooks/main?urlpath=/tree
+// :page--attr:                         <attr-value>
+:binder-badges-enabled:                 true
+:binder--home:                          https://mybinder.org/
+:binder--docs:                          https://mybinder.readthedocs.io/en/latest/
+:github-repo--binderhub:                https://github.com/jupyterhub/binderhub
+:binder-app-launch--tree:               https://mybinder.org/v2/gh/jekyll-one/j1-binder-repo/main?urlpath=/tree
 
 //  Load Liquid procedures
 // -----------------------------------------------------------------------------
@@ -94,6 +95,142 @@ endif::[]
 
 // info:        https://en.wikipedia.org/wiki/Galileo_Galilei
 
+CAUTION: Each interactive element presented on this page uses *time-consuming*
+operations that take a while to finish. The images and the interactive
+elements are built through a backend in the cloud. Please be patient
+to see the results.
+
+The Jupyter Project is a non-profit organization founded in 2014 by
+_Fernando Perez_. The Jupyter project supports interactive scientific
+Data evaluations and scientific calculations. The main applications provided
+by the Jupyter Project are:
+
+* Jupyter Notebook (JN)
+* JupyterHub (JH)
+
+NOTE: The name _Jupyter_ refers to the three main programming languages
+_Julia_, _Python_ and _R_ supported by the Jupyter Notebook App. The
+name _Jupyter_ is a homage to the notebook entries by _Galileo Galilei_
+on the discovery of the moons of Jupiter, where he made his observations
+and the measurement data together.
+
+Jupyter Notebook (JN) is an open source web application that allows data
+scientists to create and share documents that include live code, equations,
+and other multimedia resources. JN combines two components:
+
+Web application::
+a browser-based tool for interactive authoring of documents which combine
+explanatory text, mathematics, computations and their rich media output.
+
+Notebook documents::
+a representation of all content visible in the web application, including
+inputs and outputs of the computations, explanatory text, mathematics,
+images, and rich media representations of objects.
+
+== Jupyter Basics
+
+To understand this documentation better, below you find a brief description
+of JupyterHub (JH) and the three base components of Jupyter Notebook (JN).
+
+=== Jupyter Notebook App
+
+The Jupyter Notebook *App* is a server-client application that allows editing
+and running notebook documents via a web browser. The Notebook App can be
+executed on a local desktop requiring no internet access or can be installed
+on a remote server and accessed through the internet.
+
+=== Notebook documents
+
+Notebook documents (or *notebooks* for short) are documents created by the
+Notebook App, and both computer code (e.g., Python) and rich text may contain
+elements (paragraphs, equations, figures, links, etc.). Notebook documents are
+human-readable documents, alongside code descriptions and results (figures,
+  tables, etc.).
+
+=== Kernels
+
+Generally, a notebook *kernel* is a *calculating machine* that lives in the
+Jupyter Notebook App to process a Notebook document and executes its
+code. The *Ipython* kernel, used for the NBI integration, runs _Python_
+code, and produces the results.
+
+=== JupyterHub
+
+_JupyterHub_ (JH) brings the power of notebooks to *groups* of users. It
+gives users access to computational environments and resources without
+burdening the users with installation and maintenance tasks. Users can get
+their work done in their own workspaces on shared resources which can be
+managed efficiently by system administrators without having the Jupyter
+Notebook App (JN) locally installed on their systems.
+
+JupyterHub runs in the cloud or on hardware hosted on your own and makes
+it possible to serve a pre-configured data science environment to any user.
+It is customizable and scalable and is suitable for small and large teams,
+academic courses, and large-scale infrastructure (for example like the
+Binder service).
+
+== Binder
+
+Binder allows you to create custom computing environments that can be
+shared and used by many remote users. A Binder service is powered by
+link:{github-repo--binderhub}[BinderHub Repo on Github, {browser-window--new}],
+an open-source tool that runs on Kubernetes, a portable, extensible,
+open-source platform for managing containerized services. One such deployment
+lives at link:{binder--home}[Binder Home, {browser-window--new}], and is free
+to use.
+
+== The Package nbInteract (NBI)
+
+As a web technology, _Jupyter Notebook_ provides a platform for authoring
+interactive scientific documents. For example, the popular `ipywidgets`
+Python library allows users to create web-based user interfaces to interact
+with arbitrary Python functions. Users can create these interfaces using
+Python directly in the notebook instead of HTML and JavaScript, significantly
+lowering the time needed to create these interfaces.
+
+This ease of use encourages instructors and researchers to create interactive
+explanations of their work. Unfortunately, it isn't easy to *share* these
+interactive notebooks with the public. Sharing the notebook file itself
+retains full interactivity but requires *viewers* to have Jupyter, Python,
+and all other packages used in the notebook installed on their machines.
+
+The freely available Binder service circumvents this by hosting notebook
+servers pre-packaged with the necessary software. However, both of these
+options still require readers to have prior familiarity with the Jupyter
+environment, making them less suitable for use with non-technical people.
+
+Authors can convert a Jupyter notebook to a static HTML document and host
+the document as a publicly-accessible web page. However, this method does
+not preserve the interactive elements of the notebook. The resulting web
+page only contains text and images.
+
+.NBI textbook (excerpt)
+lightbox::nbi-textbook--excerpt[ 800, {data-nbi-textbook--excerpt}, role="mt-3 mb-4" ]
+// image::pages/nbinteract/nbi-textbook-example.jpg["NBI textbook (excerpt)", 800]
+
+The Python package `nbinteract` allows authors to convert Jupyter notebooks
+into *interactive*, standalone HTML pages: the textbooks. The interactive
+elements can use arbitrary Python code to generate output, including Python
+libraries that use C extensions (e.g., _NumPy_ and _Pandas_) and libraries
+that create images (e.g., _Matplotlib_).
+
+Anyone with a modern web browser can use the resulting web pages even if
+the viewer does *not* have Python or Jupyter installed on their computer.
+To make this possible, NBI uses the freely available cloud service _Binder_.
+Two communication libraries are used to interact with the _BinderHub_ and the
+_JupyterHub_ services
+
+You can find an overview of these services and their communication interfaces
+at:
+
+* link:{url-j1--binderhub}[BinderHub, {browser-window--new}]
+* link:{url-j1--jupyterhub}[JupyterHub, {browser-window--new}]
+
+TIP: The `nbinteract` package also includes additional methods for interactive
+plots (widgets) designed for very fast interaction prototyping in the notebook
+and smooth interaction on static HTML web pages.
+
+== J1 NBI Integration
 
 The integration of NBI consists of the following components:
 
@@ -121,18 +258,17 @@ NOTE: Recent library updates are more than a year ago, and the current
 version of the Jupyter Notebook *JupyterLab* application, unfortunately,
 *not* supported (yet).
 
-== Notebooks vs. Textbooks
+=== Notebooks vs. Textbooks
 
-Jupyter Notebooks with the extension `.ipynb` are (data) files in JSON
-format and can only be run using the *App* of Jupyter Notebook. On the
+Jupyter Notebook documents with the extension `.ipynb` are (data) files in
+JSON format and can only be run using the *App* of Jupyter Notebook. On the
 other hand, Textbooks are HTML exports with the extension `.html` from
 Jupyter Notebooks to be viewed in a web browser.
 
 For integrating textbooks in webpages, the notebooks with the extension
-`.ipynb` are to be *exported* to HTML (text) files using the
-(Python) program nbinteract. Textbooks that have already been exported
-can be found for the *Starter Web* in the folder
-`~/pages/public/jupyter/notebooks/textbooks`.
+`.ipynb` are to be *exported* to HTML (text) files using the (Python)
+program nbinteract. Textbooks that have already been exported can be found
+for the *Starter Web* in the folder `~/pages/public/jupyter/notebooks/textbooks`.
 
 == J1 NBI Configuration
 
@@ -230,7 +366,7 @@ time being.
 #
 defaults:
 
-  spec:                                 jekyll-one/nbinteract-notebooks/main
+  spec:                                 jekyll-one/j1-binder-repo/main
   baseUrl:                              'https://mybinder.org'
   provider:                             gh
 
@@ -319,7 +455,7 @@ settings:
 The use of J1 NBI requires a valid Binder configuration. The binder
 configuration is to be provided via a public Git repo. An example of such a
 Git repo you find on Github at
-https://github.com/jekyll-one/nbinteract-notebooks[Binder Repo, {browser-window--new}].
+link:{url-j1--gh-binder-repo}[J1 Binder Repo, {browser-window--new}].
 The configuration settings are described in the <<Default settings>> section.
 
 === Textbook configuration
@@ -336,7 +472,7 @@ For integrating textbooks (nbinteract HTML notebook) into web pages, the
 resource of J1 NBI Module is required. The `ID` of the module of the J1 NBI
 integration is: `nbinteract`.
 
-.Example Frontmatter of a page using Textbooks
+.Example of a Frontmatter for a page using Textbooks
 [source, yaml, role="noclip"]
 ----
 title:                                  J1 NbInteract
@@ -359,10 +495,10 @@ regenerate:                             true
 
 resources:                              [ nbinteract, rouge ] <2>
 ----
-<1> Binder's services require personalized settings in the *cookies* used.
-    Difficulties with the rules of privacy should be explicitly pointed out
-    and responded to in a suitable form if the cookie settings of the
-    visitor do not allow this.
+<1> Binder's services require *Personalization* accepted in the users
+    *cookie* settings. Difficulties with the rules of privacy should be
+    explicitly pointed out and responded to in a suitable form if the cookie
+    settings of the visitor do not allow this.
 <2> If highlighting the source code parts is desired in a textbook, the
     `rouge` module must included as well.
 
@@ -379,13 +515,13 @@ textbook::<notebook-id>[]
 Einbinden des Textbooks mit der ID `j1_docs_example_dynamic` in eine Webseite.
 
 .Example
-[source, conf, role="noclip"]
+[source, conf]
 ----
 textbook::j1_docs_example_dynamic[]
 ----
 
 
-== Textbook Examples
+== NBI Textbook examples
 
 For the J1 template, textbooks are typically integrated as *dynamic* HTML
 pages. In addition to the dynamic pages, textbooks can also be integrated as
@@ -399,8 +535,8 @@ Jinja templates. The tool allows you to convert an .ipynb notebook file into
 various *static* formats. For more details, refer to
 link:{url-nbconvert--doc}[nbconvert - usage, {browser-window--new}].
 
-.Generate a static Textbook
-[source, bash]
+.Generate a static textbook
+[source, sh]
 ----
 jupyter nbconvert --execute --to html <full_path_to>/<notebook.ipynb>
 ----
@@ -409,12 +545,12 @@ Below you find an static HTML output (Textbook) generated via `nbconvert`.
 
 include::{documentdir}/j1_docs_example_static.asciidoc[]
 
-=== Dynamic Textbook
+=== Interactive Textbook
 
-*Dynamic* Textbooks are generated using `nbinteract`:
+*Interactive* Textbooks are generated using `nbinteract`:
 
-.Generate a dynamic Textbook (J1 Version)
-[source, bash]
+.Generate an interactive textbook
+[source, sh]
 ----
 nbinteract <full_path_to>/<notebook.ipynb> -t plain -s fake/fake
 ----
@@ -425,124 +561,4 @@ textbook::j1_docs_example_dynamic[]
 
 Compare both textbook versions, dynamic versus static, in terms of
 *interactivity*. Again, compare the _Evaluation_ section at section
-<<Dynamic Textbook>> with the static conterpart at <<Static Textbook>>.
-
-
-
-
-
-
-/////
-== Backgrounds
-
-lorem:sentences[5]
-
-=== Jupyter
-
-Das Jupyter Projekt ist eine Non-Profit-Organisation, gegründet im Jahr 2014
-von *Fernando Pérez*. Das Projekt Jupyter unterstützt interaktive wissenschaftliche
-Datenauswertungen und wissenschaftliche Berechnungen.
-
-Der Name Jupyter bezieht sich auf die drei wesentlichen Programmiersprachen
-Julia, Python und R die von der Anwendung <<Jupyter Notebook App>> unterstützt
-werden. Die Bezeichnung *Jupyter* ist eine Hommage an die *Notizbucheinträge*
-von Galileo Galilei zur Entdeckung der Jupitermonde, bei denen er seine
-Beobachtungen und die Messdaten zusammen aufgeschrieben hatte.
-
-==== Jupyter Notebook App
-
-Die App *Jupyter Notebook* ist eine Server-Client-Anwendung, mit der
-Notebook-Dokumente über einen Webbrowser bearbeitet und ausgeführt werden
-können. Jupyter Notebook  kann auf einem lokalen Desktop ausgeführt
-werden der keinen Internetzugang erfordert. Alternativ kann die Anwendung auf
-einem Remote-Server installiert und über das Internet aufgerufen werden, die
-dann *keine* Installation erforderlich macht.
-
-==== Notebook documents
-
-Notebook-Dokumente (oder kurz: *notebooks*) sind Dokumente, die von der Notebook
-App erstellt wurden und sowohl Computercode (z. B. Python) als auch Rich-Text
-Elemente (Absätze, Gleichungen, Abbildungen, Links usw.) enthalten können.
-Notebook Dokumente sind menschenlesbare Dokumente, die neben Code Beschreibungen
-und deren Ergebnisse (Abbildungen, Tabellen usw.) enthalten.
-
-==== Kernels
-
-Ein Notebook Kernel ist ganz allgemein eine *Rechenmaschine*, die den in einem
-Notebook-Dokument enthaltenen Code ausführt. Der *Ipython* Kernel, der für die
-NBI Integration verwendet wird, führt Python-Code aus erzeugt die Ergebnisse.
-
-=== nbinteract
-
-Der Name der Library `nbinteract` deutet zwei generelle Funktionen für
-Jupyter Notebooks  an:
-
-`nb`, textbook::
-Verarbeitung von Notebooks
-// (als HTML Darstellung)
-
-`interact`::
-Ausführen von Notebooks in Zusammenarbeit mit einem (remoten) Verarbeitungs
-System und Darstellung der Ergebnisse
-
-
-==== Requirements
-
-Für die Entwicklung eigener Jupyter Notebooks ist eine *lokale*
-Installation der Programmiersprache *Python* erforderlich. Zur Entwicklung
-von Notebooks wird zusätzlich das Paket *Jupyter* sowie die Installation der
-Python Library *nbinteract* erwartet.
-
-==== Widgets
-
-Ein Widget ist ein Element einer grafischen Benutzeroberfläche (GUI), das
-Informationen anzeigt oder einem Benutzer eine bestimmte Möglichkeit bietet,
-mit dem Betriebssystem oder einer Anwendung zu interagieren.
-
-Zu den Widgets gehören Symbole, Pulldown-Menüs, Schaltflächen, Auswahlfelder,
-Fortschrittsanzeigen, Ein-Aus-Häkchen, Bildlaufleisten, Fenster, Fensterränder
-(mit denen Sie die Größe des Fensters ändern können), Umschaltflächen,
-Formulare und viele andere Geräte zum Anzeigen von Informationen und zum
-Einladen, Akzeptieren und Reagieren auf Benutzeraktionen.
-
-
-==== BinderHub
-
-// UserGuide: https://mybinder.readthedocs.io/en/latest/about/about.html
-
-Mit Binder (myBinder) können Sie benutzerdefinierte (virtuelle) Computerumgebungen
-erstellen, die von vielen Benutzern remote aus einer Cloud gemeinsam genutzt
-werden können.
-
-// erzeugt Docker Container
-// installiert Python Software
-// installiert Jupyter Lab als Notebook App
-
-.Binderhub Architecture
-lightbox::binderhub--architecture[ 800, {data-binderhub--architecture}, role="mt-3 mb-4" ]
-
-////
-Ein Binder-Dienst wird von BinderHub
-unterstützt, einem Open-Source-Tool, das auf Kubernetes ausgeführt wird,
-einer tragbaren, erweiterbaren Open-Source-Plattform zum Verwalten von
-containerisierten Diensten. Eine solche Bereitstellung befindet sich auf
-mybinder.org und kann kostenlos verwendet werden.
-////
-
-==== JupyterHub
-
-JupyterHub bringt die Leistung von Notebooks für Benutzergruppen. Es gibt
-Benutzern Zugriff auf Rechenumgebungen und Ressourcen, ohne die Benutzer mit
-Installations- und Wartungsaufgaben zu belasten. Benutzer, einschließlich
-Studenten, Forscher und Datenwissenschaftler, können ihre Arbeit in ihren
-eigenen Arbeitsbereichen auf gemeinsam genutzten Ressourcen erledigen, die
-von Systemadministratoren effizient verwaltet werden können.
-
-.JupyterLab Architecture
-lightbox::jupyterlab--architecture[ 800, {data-jupyterlab--architecture}, role="mt-3 mb-4" ]
-
-JupyterHub läuft in der Cloud oder auf Ihrer eigenen Hardware und ermöglicht
-es, jedem Benutzer weltweit eine vorkonfigurierte Data-Science-Umgebung
-bereitzustellen. Es ist anpassbar und skalierbar und eignet sich für kleine
-und große Teams, akademische Kurse und große Infrastrukturen.
-/////
+<<Interactive Textbook>> with the static conterpart at <<Static Textbook>>.

data/lib/starter_web/pages/public/jupyter/docs/nbi-widget-manual.adoc

@@ -31,14 +31,12 @@ keywords: >
 categories:                             [ Software, Python ]
 tags:                                   [ Binder, API ]
 
-scrollbar:                              true
+scrollbar:                              false
 
 permalink:                              /pages/public/jupyter/docs/nbi-widgets/
 regenerate:                             false
 
-resources:                              [
-                                          animate, clipboard, lightbox, rouge
-                                        ]
+resources:                              [ animate, clipboard, lightbox, rouge ]
 resource_options:
   - attic:
       padding_top:                      400
@@ -55,12 +53,12 @@ resource_options:
 
 // Set (local) page attributes here
 // -----------------------------------------------------------------------------
-// :page--attr:                                   <attr-value>
-:badges-enabled:                                  false
-:binder-badge-enabled:                            false
-:binder--home:                                    https://mybinder.org/
-:binder--docs:                                    https://mybinder.readthedocs.io/en/latest/
-:binder-app-launch--tree:                         https://mybinder.org/v2/gh/jekyll-one/nbinteract-notebooks/main?urlpath=/tree
+// :page--attr:                         <attr-value>
+:badges-enabled:                        false
+:binder-badge-enabled:                  false
+:binder--home:                          https://mybinder.org/
+:binder--docs:                          https://mybinder.readthedocs.io/en/latest/
+:binder-app-launch--tree:               https://mybinder.org/v2/gh/jekyll-one/j1-binder-repo/main?urlpath=/tree
 
 //  Load Liquid procedures
 // -----------------------------------------------------------------------------
@@ -105,6 +103,25 @@ hist_function (Array | (*args -> Array int | Array float)):
     histogram.
 ----
 
+.Example
+[source, python, role="noclip"]
+----
+import nbinteract as nbi
+import numpy as np
+
+def hist_response_function(mean, sd, size=1000):
+    '''
+    Returns 1000 values picked at random from the normal
+    distribution with the mean and SD given.
+    '''
+    return np.random.normal(loc=mean, scale=sd, size=1000)
+
+nbi.hist(hist_response_function, mean=(0, 10), sd=(0, 2.0, 0.2))
+----
+
+.Rendered Histogram
+lightbox::nbi-widget--hist[800, {data-nbi-widget--hist}, role="mt-3 mb-4"]
+
 === Options
 
 [source, python, role="noclip"]
@@ -149,6 +166,28 @@ y_fn (Array | (Array, *args -> Array int | Array float)):
     y-axis.
 ----
 
+.Example
+[source, python, role="noclip"]
+----
+import nbinteract as nbi
+import numpy as np
+
+def categories(n):
+    return np.arange(n)
+
+def heights(xs, offset):
+    return xs + offset
+
+opts = {
+    'ylim': (0, 20),
+}
+
+nbi.bar(categories, heights, n=(0, 10), offset=(1, 10), options=opts)
+----
+
+.Rendered Barchart
+lightbox::nbi-widget--bar[800, {data-nbi-widget--bar}, role="mt-3 mb-4"]
+
 === Options
 
 [source, python, role="noclip"]
@@ -170,7 +209,7 @@ interact_params (dict): Keyword arguments in the same format as
 ----
 
 
-== Scatter plot
+== Interactive Scatter plot
 
 The widget `nbinteract.scatter_drag` generates an interactive scatter plot
 with the best fit line plotted over the points. The points can be dragged by
@@ -182,6 +221,23 @@ x_points (Array Number): x-values of points to plot
 y_points (Array Number): y-values of points to plot
 ----
 
+.Example
+[source, python, role="noclip"]
+----
+import nbinteract as nbi
+import numpy as np
+
+x_coords = np.arange(10)
+y_coords = np.arange(10) + np.random.rand(10)
+
+opts = {'xlim': (0, 9), 'ylim': (0, 11), 'animation_duration': 250}
+
+nbi.scatter_drag(x_coords, y_coords, options=opts)
+----
+
+.Rendered interactive Scatter Plot
+lightbox::nbi-widget--scatter-drag[800, {data-nbi-widget--scatter-drag}, role="mt-3 mb-4"]
+
 === Options
 
 [source, python, role="noclip"]
@@ -223,6 +279,21 @@ y_fn (Array | (Array, *args -> Array int | Array float)):
     scatter plot.
 ----
 
+.Example
+[source, python, role="noclip"]
+----
+import nbinteract as nbi
+import numpy as np
+
+def x_values(n): return np.random.choice(100, n)
+def y_values(xs): return np.random.choice(100, len(xs))
+
+nbi.scatter(x_values, y_values, n=(0,200))
+----
+
+.Rendered Scatter Plot
+lightbox::nbi-widget--scatter[800, {data-nbi-widget--scatter}, role="mt-3 mb-4"]
+
 === Options
 
 [source, python, role="noclip"]
@@ -277,6 +348,8 @@ opts = {
 nbi.line(x_values, y_values, max=(10, 50), sd=(1, 10), options=opts)
 ----
 
+.Rendered Line Plot
+lightbox::nbi-widget--line[800, {data-nbi-widget--line}, role="mt-3 mb-4"]
 
 [source, python, role="noclip"]
 ----
@@ -318,3 +391,75 @@ interact_params (dict): Keyword arguments in the same format as
     parameter names, prefix the corresponding kwargs with `x__` and
     `y__`.
 ----
+
+== Multiple Choice
+
+Generates a multiple choice question that allows the user to select an
+answer choice and shows whether choice was correct.
+
+[source, python, role="noclip"]
+----
+nbinteract.multiple_choice(question, choices, answers)
+----
+
+.Example
+[source, python, role="noclip"]
+----
+import nbinteract as nbi
+
+nbi.multiple_choice(question="Select all prime numbers.",
+                    choices=['12', '3', '31'],
+                    answers=[1, 2])
+----
+
+.Rendered Multiple Choice
+lightbox::nbi-widget--multiple-choice[800, {data-nbi-widget--multiple-choice}, role="mt-3 mb-4"]
+
+=== Options
+
+[source, python, role="noclip"]
+----
+question (str): Question text displayed above choices.
+
+choices (list str): Answer choices that user can select.
+
+answers (int | iterable int): Either an integer or iterable of
+    integers. Each integer in answers corresponds to the index of the
+    correct choice in `choices`.
+----
+
+== Short Answer
+
+Generates a short answer question that allows user to input an answer in
+a textbox and a submit button to check the answer.
+
+[source, python, role="noclip"]
+----
+nbinteract.short_answer(question, answers, explanation=None)
+----
+
+.Example
+[source, python, role="noclip"]
+----
+import nbinteract as nbi
+
+nbi.short_answer('What is 1+1?', answers='2', explanation='1+1 is 2')
+----
+
+.Rendered Short Answer
+lightbox::nbi-widget--short-answer[800, {data-nbi-widget--short-answer}, role="mt-3 mb-4"]
+
+=== Options
+
+[source, python, role="noclip"]
+----
+question (str):  The question being asked.
+
+answers (str | list str | func): If a string, only that string will be
+    marked correct. If a list of string, any string in the list will be
+    marked correct. If a function, any input that causes the function
+    to return True will be marked correct.
+
+explanation (str):  The explanation to the question is displayed when
+    the user inputs the correct answer.
+----

data/lib/starter_web/pages/public/jupyter/docs/nbinteract-doc.adoc

@@ -60,12 +60,12 @@ resource_options:
 
 // Set (local) page attributes here
 // -----------------------------------------------------------------------------
-// :page--attr:                                   <attr-value>
-:badges-enabled:                                  true
-:binder-badge-enabled:                            false
-:binder--home:                                    https://mybinder.org/
-:binder--docs:                                    https://mybinder.readthedocs.io/en/latest/
-:binder-app-launch--tree:                         https://mybinder.org/v2/gh/jekyll-one/nbinteract-notebooks/main?urlpath=/tree
+// :page--attr:                         <attr-value>
+:badges-enabled:                        true
+:binder-badge-enabled:                  false
+:binder--home:                          https://mybinder.org/
+:binder--docs:                          https://mybinder.readthedocs.io/en/latest/
+:binder-app-launch--tree:               https://mybinder.org/v2/gh/jekyll-one/j1-binder-repo/main?urlpath=/tree
 
 //  Load Liquid procedures
 // -----------------------------------------------------------------------------
@@ -123,6 +123,11 @@ In addition, `nbinteract` provides a Python package. Once imported, the package
 provides helper methods that allow users to create simple interactive
 visualizations with single function calls.
 
+CAUTION: Each interactive element presented on this page uses *time-consuming*
+operations that take a while to finish. The images and the interactive
+elements are built through a backend in the cloud. Please be patient
+to see the results.
+
 == Getting Started
 
 The following pages will show you how to use `nbinteract` and its related