I'd like to see some things ported into Jupyter from R Notebooks, like JavaScript data tables and the separation of code and output, making it easy to version control only the code. (Atleast this 5.0 release makes tables nonugly)
I'd like to see some things ported into Jupyter from R Notebooks, like JavaScript data tables and the separation of code and output, making it easy to version control only the code. (Atleast this 5.0 release makes tables nonugly)
It's in alpha right now but they're making crazy fast progress on it. I've been using it and it's awesome
Thanks so much for all your hard work!
Or do you just mean that R Notebooks are specifically better than the R support in Jupyter?
Here's an example of one of my notebooks with all 3 things: http://minimaxir.com/notebooks/breach-network/
It's definitely a better fit for R.
https://github.com/bloomberg/bqplot
They even have gamepad/controller support, which allows dynamic interactions with widgets.
Edit: Live demo of the project from PyData London 2016: https://youtu.be/eVET9IYgbao?t=27m45s
These widgets support embedding in other contexts like static HTML pages or Sphinx docs [1]. An example can be seen on the docs [2]
[1]:http://ipywidgets.readthedocs.io/en/latest/embedding.html
[2]:http://ipywidgets.readthedocs.io/en/latest/examples/Widget%2...
Currently, Jupyter works well for development, but the result is often hard to read because code gets in the way. (unless you use nbconvert, but that sometimes defeats the purpose)
That said, both Jupyter and R Markdown Notebooks are but a pale shadow of the support offered by Org-mode (seriously!).
Know of any good resources that show this for folks that don't know what we are talking about?
Yes, but the large number of excellent notebooks available for Jupyter (and R as well) all over the web as well as support for CUDA and all kinds of extremely powerful libraries such as tensorflow) give those a serious edge over Org-mode, even though Org-mode is super powerful by itself.
If you setup a source block, you can use TRAMP to actually execute the command in a source block on a remote machine. So:
#+BEGIN_SRC sh :dir /user@remotemachine.com:~/remotedir
ls
#+END_SRC
The above will run ls on "remotemachine.com" and put the results in an output block below it.Edit: Meant to add that you can do the same with docker. Just use "/docker:dockerId:" as the dir, and it will execute in a docker instance locally. Using multihop addresses, this can get extreme.
Org mode is one of the few real literate programming tools that I'm aware of, the other one is 'Leo'.
I used to try complicated examples, which led to pages such as http://taeric.github.io/Sudoku.html. I'm now much more into writeups such as http://www.howardism.org/Technical/Emacs/literate-devops.htm.... (Note, I did not write the second one.)
I'm really intrigued by it, but Jupyter is much more clearly documented (org docs are downright sprawling), so I've always gone that path.
Other than that the plan is to keep this (or something similar) running as long as there is sufficient interest and so far there seems to be quite a bit!
Note that it does run on docker which means ultimately it's not fully "secure", but we hope to switch to hyperv-linux when it's available.
[smortaz at msft]
I'm definitely using this for my next project.
from rpy2 import robjects
my_dictionary_results = some_method()
names_dict = robjects.ListVector(my_dictionary_results)
%load_ext rpy2.ipython
%R library(some_lib)
%R -i my_dictionary_results doStuff(my_dictionary_results)
Image display etc. works fine
There are R packages which allow communicating with a server, mostly big data packages. (sparklyr allows you to connect to a remote Spark cluster)
And there's nothing wrong with knowing and using both languages.