JavaScript plugin sometime does not refreshed when eval is done. It shows "pending" and only updates when other parts of the UI triggers refresh.

Currently, if a menu is loaded dynamically (e.g. through plugin manager), the loaded menu will be gone once leaving the app. Also relatedly, there are different mechanisms exist in the system for specifying default menu plugins. These mechanisms should be unified and there should be any 1-st class menu items. The proposed plan is to add a menu config file and retrieve config from there.

Currently, the default notebook and config file sitting in the dot dir will not be updated once created. This prevents the newer version of default notebook and config to be deployed. We should apply version converter to update the old format files while preserving any user changes(maybe manual).

1. Make a Latex cell
2. Type in '1+1'
3. Press CTRL-ENTER
4. Change the code to '1+2'
5. Press CTRL-ENTER

The output doesn't update

To reproduce, open a new notebook and add a Python cell with the following content:

from pylab import *
import matplotlib.pyplot as plt
x = linspace(0, 5, 10)
y = x ** 2
figure() 
plot(x, y, 'r') 
xlabel('x')
ylabel('y') 
title('title')
show()

then try to save.

The Chrome console shows that the save request response with 500 server internal error.
Note that before evaluating the code cell or after evaluation, delete the output cell, the notebook saves fine. Only when the output cell appears (a PNG), the notebook file saving fails.

on ubuntu

Pkg.add("RDatasets")

produces

ERROR: failed process: Process(sh -c 'cd /home/sheep/.julia/v0.2/.cache/RDatasets && git rev-parse --git-dir', ProcessExited(128)) [128]
in pipeline_error at process.jl:476
in readbytes at process.jl:430
in readall at process.jl:437
in dir at git.jl:12
in git at git.jl:18
in cmd at git.jl:23
in run at git.jl:24
in set_remote_url at git.jl:96
in prefetch at pkg/cache.jl:40
in resolve at pkg/entry.jl:341
in resolve at pkg/entry.jl:316
in edit at pkg/entry.jl:24
in add at pkg/entry.jl:44
in add at pkg/entry.jl:48
in anonymous at pkg/dir.jl:28
in cd at file.jl:22
in cd at pkg/dir.jl:28
in add at pkg.jl:19

I can't see the last few lines of stdout. Screenshot attached.

since our build process counts on downloading many dependencies which might not be accessible later (or might change), we should keep a snapshot. for me right now that's 220M, 75M compressed.

This should default to true

For control panel, it looks like the custom menu plugin is loaded before the default one.

Spec is here: https://github.com/twosigma/beaker-notebook/wiki/Section-header-spec

If you scroll down, you can't zoom on charts.

you can't stop an infinite loop

if you load a plugin that hasn't been seen before, then beaker requests a restart.
instead it should rewrite nginx config and then just send it a HUP.
if this leaves existing connections unmodified then it should work.
if it works we can eliminate the ~/.beaker/plugins file.

The following should all work in Python. None of them currently do.

from IPython.display import Latex
Latex("$x_i$")

from IPython.display import Math
Math(r'x_i')

%%latex
$x_i$

that opens up web page on our home URL.com

As pointed out by @dmitri-at-twosigma: #86 (diff) right now we check the availability of a port and then use it in a non-atomic way.

Somewhere in the process of resolving merge conflicts between master and the ubuntu branch or somewhere in a new commit, something has gone awry. I'll see what I can figure out but if it is obvious to anyone else, please let me know.

15:53:51.144 [QUIET] [system.out] nginx-stderr>2014/03/06 15:53:51 [error] 26272#0: *418 connect() failed (111: Connection refused) while connecting to upstream, client: 127.0.0.1, server: , request: "POST /groovysh/cometd/handshake HTTP/1.1", upstream: "http://127.0.0.1:8806/cometd/handshake", host: "mojotech-mcd:8801", referrer: "http://mojotech-mcd:8801/beaker/"

Currently there is no mechanism to remove or replace menu items. This is desirable if customized environment wants to override menu items. One example of this is the 'Tutorial' menu item in the Help menu.

Now that we switched to use query parameters for path (ae60c5b), however, the path is still composed with prefixes that could indicate file format (ipynb, bkr) and/or file location (file system, http, dropbox, or other proprietary storages), which is undesirable.

I propose that the beaker URL should reflect the following info to be used in the session model with query parameters:

1. path, (e.g. /User/PyaneDiaz/myNotebook.bkr, or http://raw.github.com/abc/xyz.ipynb)
2. pathType (e.g. "file", "http", optional, if not provided, beaker should infer from the path)
3. fileType (e.g. bkr, ipynb. optional, if not provided, ideally beaker should read the file then guess)

More details about the proposal:

• The “/open” URL should be transient, it should load the file specified to be opened then create a session by redirecting to “/session”.
• The /open URL should use query parameters: path, pathType(optional), fileType(maybe optional),
• Alternatively, /open URL can be “/open/:uri” which should fall back to treat the uri arg as path and opts out on pathType and fileType. Also, the uri can be ‘new’ which opens a new session by loading the default notebook.
• The session URL should be as simple as “/session/:id”, user should refer to other part of UI (other than the browser address bar) for location of the file loaded.

blogger and email are good candidates.

To reproduce, create a notebook with one IPython cell, make input cell body: 1+1, and make the code cell initialization cell. Save the notebook book to a file.

And then in Beaker, open the notebook from file, the output cell of the code cell displays "pending" and never updates further.

Loading currently fails silently. We should notify the user of problems and help them fix it.

Try running some invalid code, such as:

This is not code

It will not display the error, and then no other JavaScript cells will run.

So that we get charts

Both IPython and Gorilla Repl support Latex within their Markdown cells. Let's figure out what they do and support it.

Currently the browser only appears with 'open'

our top menus turn into an icon even though the window is plenty wide enough to show them all. and then, if you click this, the navigation is horrible. this screencap is on ubuntu but i see a similar problem on mac. perhaps it works on mobile?

This is possible for some languages (e.g. Python) but doesn't make sense for others (e.g. Groovy) where the output could be asynchronous. We should consider allowing it where it makes sense.

so final page is full of many copies of

<!--
Copyright 2014 TWO SIGMA INVESTMENTS, LLC

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

-->

to reduce latency

1. Make a new notebook
2. File -> Save
3. Enter "/asdf" and click save

You'll get an exception in the console but no feedback within Beaker. (Assuming you're not root)

We need a way to communicate between cells from different evaluators. I propose this be done with a notebook namespace: a collection of variables that are part of the document model. Their values would be JSON.

Access to the variables would be by a module "beaker" written for each plugin and loaded automatically. As a baseline we would use strings for the variables with a basic get/set API: beaker.get("x") and beaker.set("x", 1). Some languages in particular Javascript might be able to better and you could just say beaker.x and beaker.x = 1. Maybe, but we could live without it.

The big question is where the namespace is stored. Since the namespace is part of the document model (including for example be saved in the notebook), naturally it should primarily exist there, in the JS in the web browser. But if code in plugin X accesses a value, it would have to make a REST call to Beaker core, which would then use comet to get the value. This round-trip could be expensive. So I propose keeping a copy of the namespace in Beaker Core, and using comet to keep the two copies synchronized. REST calls are not as fast as in-memory access but avoiding going over the WAN could be a huge win.

Mostly this synchronization can be done after the caller returns. The danger is that you will write to one side and then evaluate a cell on the other side that reads it before it has been updated. Without some kind of locking this would be possible because different channels are used for each plugin and the core. So when accessing the namespace you would have to block until you were guaranteed to get the right value. Along with the cell evaluation results you could return a flag that said there might be namespace changes coming. Similarly with the cell evaluation call you can have a flag that there might be changes coming. In both cases you only block if you need access.

This is just a performance optimization, so a first pass at implementation should probably stick with keeping one copy in the JS.

It would be possible to keep it just in the Core and not in the client. I think they are most likely to be accessed from JS though (for application development and for saving the document). Another possibility is to keep a copy in every plugin, but that would be expensive in memory, though it does give very fast access.

The big alternative to this is using cell evaluation results as the bus. Ie in one cell referring to the output of another cell. This has two problems, one is there's no obvious name to use, and two because values are not explicitly shared the optimization of duplicating the namespace becomes impractical.

Create a unified way of recording/reading user preferences and avoid hardwiring code.

Due to this problem: http://rforge.net/Rserve/rserve-win.html
We can work around this by forking multiple R backends, but we have to allocate the ports.

As Dmitri pointed out in:
#86 (diff)

for our target OSes installer should associate .bkr notebook files with our application (so you can double click on them).

which means only one instance of beaker can run R.
the solution is to allocate the port dynamically along with the rest in our block.
then pass it to the connection: RConnection(java.lang.String host, int port)
and in the Rserve script (which would have to be written dynamically too)
run.Rserve(port=9999)

need a way to remove a language from a notebook.

1. Go to control panel
2. Make a new notebook
3. Middle click the Beaker logo to open control panel in a new tab

The new notebook is not present in the list. It does show up if you left click the control panel instead of middle click.

It can't, for example, open this URL: https://raw.github.com/ptwobrussell/Mining-the-Social-Web-2nd-Edition/master/ipynb/__Chapter%201%20-%20Mining%20Twitter%20(Full-Text%20Sampler).ipynb

for example try to complete this code:
open('/Users/') by moving the cursor to between / and ' (at the end of "/Users"), hit Ctrl+space, it becomes something like:
open('//Users/alee/)
while expected result should be:
open('/Users/alee/')

What metrics do we want?

1. Open the tutorial
2. Click Help -> Tutorial notebook again

The tutorial should reload, but it doesn't. The same problem happens if you load something with File -> recent and then try the same thing again.