ipython provides a shell around the python REPL with line numbering, history, and magics. The julia REPL has a lot of great features like help and shell, but there are still some features I miss like magics, history and line numbering. Can I get these in Julia?
not looking for notebooks, e.g. Jupyter
OhMyRepl.jl is a Julia REPL enhancement library.
Related
Is it possible to save the Jupyter variables in DataSpell similar to how this works in RStudio?
At the moment, after I closed DS, I need to recompute everything. Of course I can write the main variables to disk myself, but I don't want to do that for all variables all the time.
I think the closest thing to the save/load workspace behavior in RStudio is the %store magic. IPython provides the %store magic, but %store is available in Jupyter Notebooks in DataSpell.
Here is the %store documentation: https://ipython.readthedocs.io/en/stable/config/extensions/storemagic.html
I am using Julia.
I am trying to get some greek characters in Jupyter notebooks.
First I downloaded the latest version of Julia 1.6.2
For the jupyter connection I used anaconda, in julia repl i put ] add IJulia, and then I could chose the Julia kernel in Jupyter.
Then a friend suggested to download vs code (since we got a problem in the working directory with jupyter-anaconda)
In VS code we got no problem with working directories. And to work with notebooks we installed the Jupyter extension. It was working very well, but we got to this problem that we cannot get greek characters.
In Jupyter (anaconda) I could easily put greek characters, like this:
no package needed, nothing, just like that.
However in VSCode I cannot get that, nor "predictive text" or coding suggestions:
Any tips on how to solve this?
Like we are preferring VS Code and we know there's a way to get the greek characters on it, but we don't know how.
Any help is very welcomed.
Thanks in advance.
Check out the docs for the Julia extension in VS code here: https://code.visualstudio.com/docs/languages/julia. Per the comments above, make sure this is installed and you have the Julia kernel selected. You should then see the following:
I've been prototyping some julia code in a Jupyter notebook, but it's outgrown the notebook format and I want to put it in a script in order to organise it properly. However, I can't work out how to get Plots to work in a script, and can't find any documentation about it.
Here's a minimal not-working example:
using Plots
gr()
display(plot([1,3,2]))
println("here")
This code takes 20-30 seconds to import Plots, then opens a window but immediately closes it again, prints "here", and exits. I can't use ctrl-C while the import process is happening.
So, I have three questions:
How do I prevent the plot window from closing as soon as it opens? What I want is for the script to block or (ideally) enter an event loop until the window is closed, and terminate after that.
Can the extremely long import time be reduced somehow?
Does any documentation exist for using Plots outside of a Jupyter environment?
If it makes a difference, I'm using julia 1.1.1 on a Mac.
The most natural way to achieve the workflow you're looking for in the first bullet is to use Juno or VS Code. Suppose in your working directory you have the following code in a file script.jl:
using Plots
gr()
display(plot([1,3,2]))
hello = "world"
println("here")
Now fire up Juno or VS Code and launch the integrated Julia REPL. From the Julia REPL, you can use include to source your script:
julia> include("script.jl")
Plot{Plots.GRBackend() n=1}
here
Now your script has been completely run and the plot is available for viewing in the plot pane (this is true for both Juno and VS Code). Now you can continue to include other files in the REPL or run other code interactively. Note that variables defined in script.jl are available for use:
julia> hello
"world"
EDIT:
If you run a script using the -i option (for interactive), the plot GUI will stay open and a REPL will launch after the script is done running:
$ julia -i script.jl
The various options to the Julia executable can be found here, or can be found by typing $ julia --help in a terminal.
The import time can be eliminated by compiling the Plots.jl package ahead of time and baking it into your julia executable using the PackageCompiler.jl package. Here is a link to the package website
https://julialang.github.io/PackageCompiler.jl/dev/
See the tutorial on how to do this, the first tutorial is about compiling a syntax highlighting package. That one replaces your default 'sysimage'. The second tutorial is about creating a loadable 'sysimage' where Plots.jl is compiled, and starting Julia with this 'sysimage' so it doesn't have to complie Plots.jl again.
However I coudln't get the second 'loadable sysimage' working so I used the first tutorials way even for Plots.jl.
After this change, using Plots and plot() are basically instant.
I'm a Python beginner and recently came across the Atom editor and the package Hydrogen, that implements the Jupyter notebook. I did so after realizing that running the notebook in Chrome consumed way too many resources and also seemed to be a bit slower.
However, the Atom editor and Hydrogen always output prints within a little frame in the code (see image). Unfortunately, it doesn't use the full window width. I also don't see any console/terminal for installing pip libraries.
Is there a way to have the output in a console below the code, just as in Jupyter, and to have a terminal?
this comes most certainly too late, but in case someone else searches for this:
hit control+shift+P / cmd+shift+P and type "toggle output area".
This is my first foray into Jupyter Notebooks. My background is in Java and Scala development in classical IDEs (e.g. IntelliJ, Eclipse).
I have Jupyter Notebook 5.0.0 installed with only two nbextensions: jupyter-js-widgets and beakerx.
My Python 3 notebooks allow me to use the tooltip feature (i.e. if I were to hit the combination shift+tab inside a method's parenthesis, I get expected arguments). However my Scala and Groovy notebooks do not (but I can run the cells just fine).
Is this expected or am I missing something? If this is expected, how do folks author in the notebooks without the ability to discover method arguments like you can in a standard IDE?
First, you have to run your statements (import module and declarations) by SHIFT + ENTER. Then it will show you tooltip after Shift + Tab was pressed.
See here: https://github.com/twosigma/beakerx/issues/6598
Tl;dr - BeakerX doesn't support this yet. Version 0.10.0 brings us one step closer.