This talk will explain how to intimately integrate IPython with your favorite text editor, as well as how to customize the IPython Notebook interface to behave in a way that makes sense to you. Though the concrete examples are centered around the world-view of a particular text editor, the content will be valuable to anyone wishing to extend and customize IPython for their own purposes.
This talk will cover two projects: vim-ipython (1) and ipython-vimception (2)
1. Most people think of IPython as an application - but much of it is written as a library, making it possible to integrate with other tools.
vim-ipython is a Vim plugin that was first written during the sprints at SciPy
2011 as a two-way interface between the Vim text editor and a running IPython
kernel. It turns vim into a frontend for IPython kernels, like the qtconsole
and the notebook interface. It allows you to send lines or whole files for
IPython to execute, and also get back object introspection and word completions
in Vim, like what you get with: object?
<enter> and object.
<tab> in IPython. It
currently has over 430 star gazers on GitHub. Because vim-ipython simply
leverages much of existing IPython machinery, it allows users to interact with
non-Python kernels (such as IJulia and IHaskell) in the same manner from the
convenience of their favorite text editor. More recently, vim-ipython has
gained the ability to conveniently view and edit IPython notebooks (.ipynb
files) without a running an IPython Notebook server.
vim-ipython has a small and accessible code base (13 people have contributed patches to the project), which has frequently made it the reference example for how to implement and utilize the IPython messaging protocol that allows for the language-independent communication between frontends and kernels.
2. The IPython Notebook user interface has become highly customizable, and authoring code and content in the Notebook can be more pleasant and productive experience if you take the time to make it yours.
IPython 2.0 brings a modal notion to the Notebook interface. There are two
modes: edit and mode command mode. In command mode, many single-key keyboard
shortcuts are available. For example,
m changes the current cell type to
b will insert a new cell above and below the current one,
and so on. Edit mode removes these single key shortcuts so that new code and
text can be typed in, but still retains a few familiar shortcuts, such as
Shift-Enter for cell execution (with some nuanced
Part of the motivation behind the introduction of this modal interface was that
performing operations on notebook cells became a tedious and awkward, as most
Ctrl-m to be typed too many times. For example, inserting 3 cells involved
Ctrl-m a Ctrl-m a Ctrl-m a, whereas now it's just
aaa in Command mode. But
the other major reason for the modal refactor was to make it possible to add
and remove shortcuts. For example, a user who finds it annoying that
for "insert above" and
b for "insert below" and thinks that
a for "insert
b for "insert before" makes more sense will now be able to make
that change for herself.
Some of the keyboard shortcuts in command mode are already vi-like (
to move up and down between cells) but many are not, and a few are confusingly
placed. ipython-vimception aims to be a reference implementation for how to
perform shortcut and user interface customization in the notebook. In
particular, along with vim-ipython's new ability to edit .ipynb files,
ipython-vimception addresses the concerns of many die-hard vim aficionados.
Many of them have otherwise shied away form the notebook interface as it
offends their sensibilities for how text editing and document manipulation
should be done. However, with the new customizable shortcut system in IPython,
along with a vim emulation mode in cell text input areas, they finally will
have a way to stay productive without having to change their ways.