5

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.

N. Virgo
  • 7,970
  • 11
  • 44
  • 65
  • I surmise that you have the above code in a file, say `script.jl`, and are calling `$ julia script.jl`. It appears that the plot GUI only stays open while the julia process is running. Once the process reaches the end of the script, the process terminates and you lose your GUI. I think you have to either use `savefig` to save your plot to a file or work interactively via the REPL, Juno, or VS Code. – Cameron Bieganek May 22 '19 at 04:12
  • The long load time for Plots.jl is commonly lamented. :) – Cameron Bieganek May 22 '19 at 04:14
  • Regarding your third point, you shouldn't have to do anything special to plot using Plots.jl interactively from the REPL, Juno, or VS Code. – Cameron Bieganek May 22 '19 at 04:16
  • @clbieganek for the first point, I've edited to be clearer about what I want. My hope was to replicate my current Python workflow, where my scripts do some calculations and then pop up a window that shows the results until I close it. If this workflow isn't feasible, it may be that Julia is not the right solution for me at the current time, sadly. (I don't want to run everything in a notebook/REPL because that can cause subtle issues with repeatability.) – N. Virgo May 22 '19 at 04:25
  • Repeatability is a very valid concern. To address that, you might consider writing your code as a Julia package and including unit tests. The Julian style is to write many very short functions (the "Single Responsibility Principle"). And the smaller the functions are, the easier it is to add unit tests for those functions. – Cameron Bieganek May 22 '19 at 04:54
  • Here's the simple answer: `$ julia -i script.jl`. (I edited my answer below to include this.) – Cameron Bieganek May 22 '19 at 05:23

2 Answers2

3

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.

Cameron Bieganek
  • 7,208
  • 1
  • 23
  • 40
1

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.

wos
  • 31
  • 4