Network Analysis Made Simple is a live workshop that moved from Jupyter to marimo

The launch path is pixi and marimo, not Jupyter

The Quick Start section at the top of the README is short, and it does not use Jupyter. You clone the repository, install pixi, which is described as the package manager, and then launch the notebooks.

git clone https://github.com/ericmjl/Network-Analysis-Made-Simple
cd Network-Analysis-Made-Simple

pixi run notebook

The README then explains what that command actually does: pixi automatically creates an isolated environment with all dependencies and launches marimo edit --no-token notebooks/. Your browser opens to the notebook directory, where you click on any notebook to run it.

Two details matter for a reader who has seen the older version of this tutorial. The notebooks are marimo notebooks rather than Jupyter notebooks, and marimo is a reactive notebook format where cells re-run when their dependencies change, which suits a tutorial where each step builds on the last. The --no-token flag suppresses the editor's token prompt, which is a small thing that makes a workshop smoother.

The dependency list in pyproject.toml confirms marimo is a first-class dependency, at marimo>=0.15 with an upper bound below 0.24, alongside networkx>=3.4, numpy>=2.0, pandas>=2.2 and matplotlib>=3.9. The version floors are recent, and requires-python is 3.11 or newer, so the environment assumes a current Python.

The Jupyter and Binder instructions are still there, inside a comment

A large part of the README is wrapped in an HTML comment, and it is worth knowing what is in it because it is the previous generation of the same tutorial. The commented section is headed Getting Started, and it offers a Binder button for participants who do not want to set anything up, noting that the option should be considered only if your WiFi is stable.

It also lists full HTML versions of every notebook for tutorial participants who might run into technical issues, with a specific URL for each: the pre-tutorial exercises, the introduction, NetworkX basics, hubs and paths, cliques triangles and structures, graph I/O, bipartite graphs, the Game of Thrones case study, the US airports case study, and two bonus notebooks on network statistical inference and graph matrix representations.

The local setup section in the comment follows the older pattern. On a Unix-like machine with the Anaconda distribution of Python 3 you run make conda, which wraps conda env create -f environment.yml, the activation of the nams environment, and python checkenv.py. Without Anaconda, make venv creates a virtualenv named network, installs from requirements.txt, and runs the same checkenv.py.

So the repository carries two eras of setup instructions. The live one is pixi, and the archived one is conda and virtualenv, with a Binder fallback and static HTML copies for people whose laptops misbehave during a workshop. The fact that both are maintained in the same file tells you how the project has evolved, and it also means a reader should follow the Quick Start rather than the comment, since the comment refers to requirements.txt and environment.yml files that the current pyproject-based setup does not use.

The notebook sequence is the curriculum, and it ends in two case studies

The material is designed for a live tutorial presentation, with the code available to reference afterwards, and it has been presented at multiple conferences, PyCon, SciPy, PyData and ODSC, in formats ranging from 1.5 hour to 4 hour long workshops. That range is the key constraint on how you use it. The same repository is designed to be delivered live in a room and then worked through alone, which is why there are instructor versions of the notebooks and why the pre-tutorial exercises exist as a separate notebook.

The ordering that the HTML list exposes is the structure of the course. It opens with pre-tutorial exercises and an introduction, moves into NetworkX basics, then hubs and paths, then cliques, triangles and structures, then graph I/O, then bipartite graphs. The two case studies come last, with the Game of Thrones one in slot seven and the US airports one in slot eight, followed by bonus notebooks on network statistical inference and graph matrix representations.

That order is a deliberate pedagogical choice and it is the one thing a self-learner should not rearrange. Graph I/O sits in the middle, which means you learn how to load real data before you do anything with it, and the case studies come after the structural material, so the bipartite and clustering work in the airport case has something to sit on. The bonus notebooks are marked as bonus, and network statistical inference in particular is the kind of material that assumes a shared vocabulary the earlier sessions built.

The notebooks live in the notebooks/ directory, and there is a matching nams/ directory that holds the package code, plus data/ and docs/ for the supporting material and an archive/ directory for older content.

The repository is also an installable package called nams

The pyproject.toml builds a distribution named nams, at version 0.0.3, with a readme and requires-python set to 3.11 or newer. That detail is easy to miss and it changes what the repository is.

The dependency list tells you what a working session in this tutorial needs. Alongside marimo, networkx, numpy, pandas and matplotlib, there is nxviz for graph visualisation, plotly, pyprojroot, python-louvain for community detection, pyjanitor for dataframe cleaning, tqdm and markdown. The HivePlot and nxviz combination is a tell: the material teaches hiveplot style visualisations, and the commented README notes that nxviz implements Circos plots while HivePlots are being migrated over.

The package also inherits a small library of supporting directories. There is a.devcontainer/ directory and a Dockerfile-oriented.dockerignore, a.pre-commit-config.yaml, a.pyup.yml for dependency updates, a mkdocs.yml for the documentation site, an nbconvert_config.py, a postBuild file for Binder, a scripts/ directory and a CONTRIBUTORS file.

The tooling configuration is unusually strict for a tutorial. Interrogate is configured with fail-under = 100, so docstring coverage has to be complete, and pytest is configured with addopts of -v --cov --cov-report term-missing and a testpaths entry pointing at a tests directory. Ruff selects the E, F and I rule sets, black runs at line-length 88 targeting py39, and isort uses the black profile.

The Makefile still builds docs and serves them on port 8149

The Makefile is small and shows how the project is published rather than how it is run. The docs target runs mkdocs build, and the serve target does the same and then serves the built site with a plain Python HTTP server.

python -m http.server 8149 -d site/

That is a deliberate choice: the documentation is static, and serving it needs nothing more than the standard library. The readme target is a separate path, using pandoc to convert README.md into docs/index.html with a gh.css stylesheet, and copying a custom logo image into the docs tree.

The check target is the environment sanity check, running python checkenv.py, and there is a checkenv.py at the repository root. That script was the gate in the older setup as well, where both the conda and the venv targets ended with the same call, so the project has always had a way to tell a participant whether their environment is broken before the workshop starts rather than during it.

The format target runs isort and black, and the older conda and venv targets are still present. The one target that no longer fits the current setup is conda, because it calls python setup.py develop, which is a deprecated packaging path, while the current environment is defined entirely in pyproject.toml and resolved by pixi.

MIT licensed, versioned at 0.0.2, and taught in rooms

The licence is MIT, and the LICENSE file is at the repository root, so the material can be reused, adapted and redistributed as long as the notice and the licence text travel with it. That is a licensing fact rather than legal advice.

There is a request attached to reuse, and it is a reasonable one. If you teach with the repository material, the README asks that you make a fork rather than a new repository where possible, that you ping the issues tracker, that you provide proper attribution back to the original in the primary landing page of the derivative work with a specified sentence naming the original tutorial and its URL, and that you provide a lightweight overview of your modifications, for instance a plain text HISTORY file or a section in the forked README. It also asks that you loop back recordings so they can be linked from the original repository.

The release history is thin and reflects what this project is. The listed releases are v0.0.2 on 2025-04-21, nx2.4 on 2020-08-30 tagged as the NetworkX 2.4 release, and odsc2019 on 2019-10-30 tagged as ODSC West 2019. The tags are a mix of package versions and conference editions, which is a reminder that the versioning here tracks the material rather than an API. The repository is not archived, the default branch is main, and the last push was on 2026-10-14, so the notebooks are still being touched.

The support model is also stated. Sharing the material, buying the LeanPub eBook, and sharing it with colleagues are the three suggested ways to support the project, and the project site at ericmjl.github.io is the fuller version of what the README summarises.

A book and a live workshop are different teaching formats

The realistic alternative to working through this repository is the LeanPub eBook that the README asks readers to buy, and the difference between them is a difference of format rather than of content.

The repository is built for the room. It has instructor versions of the notebooks alongside the student versions, a pre-tutorial exercises notebook that participants do before the session, static HTML copies for anyone whose laptop fails mid-workshop, a Binder link for people with stable WiFi who would rather not set anything up, and a checkenv.py that validates the environment ahead of time. None of that matters if you are reading alone at your own pace, and all of it matters if you are standing in front of a room of thirty people with a projector.

The book inverts the priorities. It can be read on a train, it can be paused on, and it does not need a second screen showing the instructor's version. What it cannot do is give you the timing. A 1.5 hour workshop and a 4 hour workshop using the same notebooks are different experiences, and the material is written to be paced live, with the instructor deciding where to spend the extra time.

There is a third route worth naming, and it is the one the material itself points at. The pre-read and supplementary material that the author recommends, the books and long-form writing on network analysis, teaches the concepts in more depth and at a slower pace than a workshop can. Combining that with these notebooks gives the concepts and the practice, which is the combination the repository is really designed for, since it assumes you arrive knowing some graph theory already.

Editorial conclusion

Network Analysis Made Simple fits a Python developer who learns better by working through a taught sequence than by reading a reference, and who wants the instructor and student versions of the same material. It does not fit someone looking for a maintained library or a production graph toolkit, since the package version is 0.0.3 and the value is in the teaching, not the code. Before starting, install pixi, run pixi run notebook to launch the marimo notebooks, and check the notebook list in the repository, because the ordering of the sessions is the curriculum and the case studies assume the earlier material.

Frequently asked questions

Official sources

1. ericmjl/Network-Analysis-Made-Simple on GitHub
2. License: MIT
3. Project website
4. README
5. Releases