Part of the vision behind the Jupyter notebook ecosystem seems to be the desire to create a literate computing infrastructure that supports “the weaving of a narrative directly into a live computation, interleaving text with code and results to construct a complete piece that relies equally on the textual explanations and the computational components” (Fernando Perez, “Literate computing” and computational reproducibility: IPython in the age of data-driven journalism, 19/4/13).
The notebook approach complements other live document approaches such as the use of Rmd in applications such as RStudio, providing an interactive, editable rendered view of the live document, including inlined outputs, rather than just the source code view.
Notebooks don’t just have to be used for analysis though. A few months ago, I spotted a notebook being used to configure a database system, db-introspection-notebook – my gut reaction to which was to ponder Literate DevOps? Could We Use IPython Notebooks To Build Custom Virtual Machines?. (A problem with that approach, of course, is that it requires notebook machinery to get started, whereas you might typically want to run configuration scrips in as bare bones a system possible.)
Another post that caught my eye last week on Jupyter Notebooks as RESTful Microservices which uses notebooks to define an API using a new Jupyter Kernel Gateway:
[a] web server that supports different mechanisms for spawning and communicating with Jupyter kernels, such as:
- A Jupyter Notebook server-compatible HTTP API for requesting kernels and talking the Jupyter kernel protocol with them over Websockets
- A[n] HTTP API defined by annotated notebook cells that maps HTTP verbs and resources to code to execute on a kernel
Tooling to support the creation of a literate API then, that fully respects Fernando Perez’ description of literate computing?!
At first glance it looks like all the API functions need to be defined within a single notebook – the notebook run by the kernel gateway. But another Jupyter project in incubation allows notebooks to be imported into other notebooks, as this demo shows: Notebooks as Reusable Modules and Cookbooks. Which means that a parent API defining notebook could pull in dependent child notebooks that each define a separate API call.
And because the Jupyter server can talk to a wide range of language kernels, this means the API can implemented using a increasing range of languages (though I think that all the calls will need to be implemented using the same language kernel?). Indeed, the demo code has notebooks showing how to define notebook powered APIs in python and R.
2 thoughts on “Using Jupyter Notebooks to Define Literate APIs”
Jupyter is nice but there are also other, simpler ways to do things like the “literate DevOps”. E.g. Emacs with Org-mode (http://orgmode.org) provided the multi-language “notebooks” (with export to html, pdf,…) for years. For example http://www.howardism.org/Technical/Emacs/literate-devops-examples.html. I use Org-mode all the time for reproducible research with R and SQL, and DevOps-like work with bash.
Thanks for that link. Agreed there are other approaches, and tools come and go; but environments and ecosystems matter, I think, when it comes to adoption. And for all the power of good editors and plugins, I think the notebooks have a quite friendly appeal to them.
(One thing that continues to interest me is how to increase access to “programming” like things for folk who don’t consider themselves programmers. )
Comments are closed.