Jupyter Lab Setup

Why Jupyter for Scientific Computing

Jupyter notebooks combine code, output, equations, and narrative in a single document. They are the standard tool for exploratory data analysis, prototyping, and sharing results in computational science. JupyterLab extends this with a full IDE-like interface: file browser, terminals, and extension ecosystem.

Definition:

JupyterLab Architecture

JupyterLab is a web-based IDE built on three components:

  • Kernel: a process that runs code (Python, R, Julia, etc.)
  • Notebook server: manages files and kernel lifecycle
  • Frontend: browser-based UI with tabs, file browser, terminals
# Install
pip install jupyterlab

# Launch
jupyter lab --port 8888

Key shortcuts: Shift+Enter (run cell), Esc (command mode), A/B (insert cell above/below), DD (delete cell).

JupyterLab replaces the older "classic" Jupyter Notebook interface. Always use JupyterLab for new projects.

Definition:

Essential JupyterLab Extensions

Install extensions to enhance your workflow:

# Table of contents sidebar
pip install jupyterlab-toc

# Interactive widgets
pip install ipywidgets

# Code formatting
pip install jupyterlab-code-formatter black isort

# Git integration
pip install jupyterlab-git

# Variable inspector
pip install jupyterlab-variableInspector

Definition:

Remote Jupyter via SSH Tunnel

Run JupyterLab on a powerful remote server and access it locally:

# On the server
jupyter lab --no-browser --port 8888

# On your laptop (SSH tunnel)
ssh -N -L 8888:localhost:8888 user@server

# Open http://localhost:8888 in your browser

Alternatively, use VS Code's Remote-SSH extension with its built-in Jupyter support for a seamless experience.

Theorem: Kernel State Is Execution-Order Dependent

A notebook's state depends on the order cells were executed, not their position in the document. If cell 3 defines x = 5 and cell 1 later sets x = 10, then x is 10 regardless of cell position.

This creates a class of bugs unique to notebooks: "it works when I run all cells top-to-bottom, but breaks if I re-run individual cells."

The kernel is a persistent Python process. Executing cells out of order is like typing commands in the wrong sequence at a terminal.

Example: Interactive Parameter Exploration with ipywidgets

Create an interactive widget that lets you adjust SNR and see the BER curve update in real time.

Solution
Implementation
import numpy as np
import matplotlib.pyplot as plt
from scipy.special import erfc
from ipywidgets import interact, FloatSlider

def plot_ber(snr_max=15):
    snr_db = np.arange(0, int(snr_max) + 1)
    snr = 10**(snr_db / 10)
    ber = 0.5 * erfc(np.sqrt(snr))

    fig, ax = plt.subplots(figsize=(6, 4))
    ax.semilogy(snr_db, ber, 'o-')
    ax.set(xlabel='Eb/N0 (dB)', ylabel='BER',
           ylim=[1e-6, 1])
    ax.grid(True, which='both', alpha=0.3)
    plt.show()

interact(plot_ber, snr_max=FloatSlider(min=5, max=30,
                                       step=1, value=15))

Jupyter Kernel State Demo

Visualize how cell execution order affects variable state.

Parameters

Common Mistake: Forgetting to Restart Kernel Before Sharing

Mistake:

Sharing a notebook without first doing "Restart Kernel and Run All Cells." The notebook may depend on variables from deleted cells or out-of-order execution.

Correction:

Always run "Kernel → Restart & Run All" before sharing or committing. If it fails, your notebook has hidden state dependencies.

Common Mistake: Large Outputs Bloating Notebook Files

Mistake:

Printing 10000-row DataFrames or embedding high-res images in output cells. This makes .ipynb files multi-megabyte.

Correction:

Use df.head(), limit plot DPI in notebooks, and clear outputs before committing with jupyter nbconvert --clear-output.

Quick Check

What is a Jupyter kernel?

The browser tab running the notebook

A separate process that executes code and returns results

The notebook file on disk

A LaTeX rendering engine

Correction:
A separate process that executes code and returns results

The kernel is a Python (or other language) process that runs code cells and maintains state.

Key Takeaway

Always "Restart Kernel and Run All" before sharing a notebook. If the notebook does not run cleanly top-to-bottom, it has hidden state dependencies that will confuse collaborators.

Historical Note: From IPython to Jupyter

2001-2018

Fernando Perez created IPython in 2001 as an enhanced Python shell for his physics PhD. In 2011, IPython added a web-based notebook interface inspired by Mathematica. In 2014, the project was renamed Jupyter (Julia + Python + R) to reflect its language-agnostic architecture. JupyterLab, the next-generation interface, launched in 2018.

Jupyter

An open-source platform for interactive computing, supporting notebooks that combine code, output, and narrative text.

Kernel

A language-specific process that executes code cells in a Jupyter notebook and maintains state between executions.

ipywidgets

A library providing interactive HTML widgets (sliders, dropdowns, buttons) for Jupyter notebooks.

Prerequisites & NotationEffective Notebook Patterns