This notebook has instructions on how to use the
debuggingbook code in your own programs.
In short, there are three ways:
fuzzingbook.orgpages; this will lead you to a preconfigured Jupyter Notebook environment where you can toy around at your leisure.
pip install fuzzingbook, you can install all code and start using it from your own code. See "Can I import the code for my own Python projects?", below.
Yes, you can! (If you like Python, that is.) We provide a
debuggingbook Python package that you can install using the
pip package manager:
$ pip install debuggingbook
debuggingbook 1.1, this is set up such that additional required Python packages are also installed. However, also see "Install Additional Non-Python Packages" below.
pip is complete, you can import individual classes, constants, or functions from each notebook using
>>> from debuggingbook.<notebook> import <identifier>
<identifier> is the name of the class, constant, or function to use, and
<notebook> is the name of the respective notebook. (If you read this at debuggingbook.org, then the notebook name is the identifier preceding
".html" in the URL).
Here is an example importing
Debugger from the chapter on debuggers, whose notebook name is
>>> from debuggingbook.Debugger import Debugger >>> with Debugger(): function_to_be_observed()
The "Synopsis" section at the beginning of a chapter gives a short survey on useful code features you can use.
debuggingbook 1.1, Python 3.9 and later is required. Specifically, we use Python 3.9.7 for development and testing. This is also the version to be used if you check out the code from git, and the version you get if you use the debugging book within the "mybinder" environment.
To use the
debuggingbook code with earlier Python versions, use
$ pip install 'debuggingbook=1.0.1'
Our notebooks generally assume a Unix-like environment; the code is tested on Linux and macOS. System-independent code may also run on Windows.
Yes, you can! First, you install the
debuggingbook package (as above); you can then access all code right from your notebook.
Another way to use the code is to import the notebooks directly. Download the notebooks from the menu. Then, add your own notebooks into the same folder. After importing
bookutils, you can then simply import the code from other notebooks, just as our own notebooks do.
Here is again the above example, importing
Debugger from the chapter on debuggers – but now from a notebook:
from Debugger import Debugger
with Debugger(): x = 1 + 1
If you'd like to share your notebook, let us know; we can integrate it in the repository or even in the book.
Yes, you can! We have a few continuous integration (CI) workflows running which do exactly that. After cloning the repository from the project page and installing the additional packages (see below), you can
notebooks and start
jupyter right away!
There also is a
Makefile provided with literally hundreds of targets; most important are the ones we also use in continuous integration:
make check-importschecks whether your code is free of syntax errors
make check-stylechecks whether your code is free of type errors
make check-coderuns all derived code, testing it
make check-notebooksruns all notebooks, testing them
If you want to contribute to the project, ensure that the above tests run through.
Makefile has many more, often experimental, targets.
make markdown creates a
.md variant in
markdown/, and there's also
make word and
make epub, which are set to create Word and EPUB variants (with mixed results). Try
make help for commonly used targets.
Yes, you can! You can download the code as Python programs; simply select "Resources → Download Code" for one chapter or "Resources → All Code" for all chapters. These code files can be executed, yielding (hopefully) the same results as the notebooks.
The code files can also be edited if you wish, but (a) they are very obviously generated from notebooks, (b) therefore not much fun to work with, and (c) if you fix any errors, you'll have to back-propagate them to the notebook before you can make a pull request. Use code files only under severely constrained circumstances.
If you only want to use the Python code, install the code package (see below).
We have attempted to limit the dependencies to a minimum (sometimes using ugly hacks). Generally speaking, if you encounter that a module
X is not found, just do
pip install X. Most notebooks only need modules that are part of the standard Python library.
For a full list of dependencies, there are two sources.
requirements.txt file within the project root folder lists all Python packages required.
You can do
$ pip install -r requirements.txt
to install all required packages (but using
pipenv is preferred; see below).
On macOS, if you use
$ conda install graphviz
If you use HomeBrew, run
$ brew install graphviz
If you wish to install the debuggingbook in an environment that is isolated from your system interpreter, we recommend using Pipenv, which can automatically create a so called virtual environment hosting all required packages.
To accomplish this, please follow these steps:
Install Pipenv following the official installation instructions.
If you have
pyenv installed, Pipenv can automatically download and install the appropriate version of the Python distribution.
Otherwise, Pipenv will use your system interpreter, which may or may not be the right version.
$ pipenv install -r requirements.txt
debuggingbook root directory.
See above for instructions on how to install additional non-python packages.