Sharing data between Julia, R, and Observable cells

[karimn]

Hi,

I'm loading some data in a Julia cell and was wondering if I can share such a data object with R or Observable cells? I know there is a function that allows sharing data from R and Python to Observable, but is there something similar for Julia?

[cscheid]

I'm loading some data in a Julia cell and was wondering if I can share such a data object with R or Observable cells?

same function name, ojs_define. Note that you can't share data between Julia and R; ojs_define shares data from the execution language to ojs cells.

[karimn]

I get an error if I use ojs_define in Julia. Is there a package I need to import/use?

[cscheid]

What error are you getting? If you were missing the needed installations, you'd see the error on the webpage:

After installing those packages, you get this:

[cderv]

On additional note, Quarto supports knitr to run the R chunks and R / knitr ecosystem have tools for multi language, like JuliaCall

So when using R with Quarto doc, you can use JuliaCall engine to run some Julia, then use a R chunk to retrieve some Julia variable, and possibly pass it to OJS using ojs_define.

This is using all knitr computation engine from Quarto perspective. This gave me the opportunity to test it quickly. Here is an example which requires R, JuliaCall R package, a Julia installation on PATH.

---
title: Julia R and Observable
format: html
engine: knitr
---

R chunk with value passed to OJS
```{r}
a <- 1
a
ojs_define(a = a)
```

Julia chunk that will be executed with Julia through JuliaCall R package

```{julia}
b = 2
```

Using R chunk to retrieve value computed in Julia and pass it to OJS

```{r}
ojs_define(b = JuliaCall::julia_eval("b"))
```

Computing in OJS using value define in R and Julia

```{ojs}
a + b
```

This shows this is possible. :) Python could even be added through the use of reticulate R package

[cderv]

I didn't know knitr supported juliacall! 🤯

Yes you can do a lot of things with knitr engine as some great R packages are leveraging the features and offers really good integration to other language and tools !

I have to use R to pass data from Julia to Observable and there isn't a direct Julia to Observable way to do this.

You can pass data from Julia to Observable without R using ojs_define() as @cscheid mentioned before. I thought you wanted to share between Julia and R, or Julia, R and observable hence my example. If you just need the Julia and ojs interop then you can just follow our documentation using Julia with Quarto directly, and using ojs_define() special quarto funciton to pass value to OJS

---
title: Julia and Observable
format: html
jupyter: julia-1.8
---

Julia chunk requires IJulia and JSON (for `ojs_define()` to work)

```{julia}
b = 2
ojs_define(x = b)
```

Computing in OJS using value define in Julia

```{ojs}
1 + x
```

Is this what you were looking for ?

[karimn]

Yes, this does work. I must apologize, I was doing something different. I was running the code cell in vs code and not rendering the qmd file. It should have been obvious that it wouldn't work! I'm basically moving from using RStudio notebooks for R only to learning how to combine Julia and R (and now Obserable) in vs code using Quarto, so I'm coming into this with a lot of misconceptions :-).

[cderv]

No problem. I also got bitten by the executing a cell using ojs_define(). I don't know if we can make something to warn and explain to user. We'll see.

Do no hesitate to ask like you did. This is a good opportunity for us to come up with examples like above and know what users are doing and would need more documentations. Thanks a lot !

Combining language is not the most straightforward. I would say best experience will be with R and knitr (but I am probably biased)

• R and Python using reticulate
• R and Julia using JuliaCall

and probably more with other package I don't recall or don't know.

Anyway, thanks for the question

[cscheid]

Ok, so it sounds like I have to use R to pass data from Julia to Observable and there isn't a direct Julia to Observable way to do this.

Just to clarify: my solution does not use R. This is the entirety of the source code I used.

---
title: asdf
jupyter: julia-1.8
---

```{julia}
ojs_define(x=5)
```

```{ojs}
x
```

[cderv]

Yes same as second example I shared in #4303 (reply in thread) 😉

[eitsupi]

If you are willing to store your data in an external file, I also recommend using an Apache Arrow file as an intermediate format.
The advantage of this method is that it is error-free, even outside of Quarto rendering.

https://quarto.org/docs/interactive/ojs/data-sources.html#file-attachments

```{r}
arrow::write_feather(
  mtcars, 
  "data.arrow", 
  compression = "uncompressed"
)
```

```{ojs}
data = FileAttachment("data.arrow").arrow()
```

Arrow files are also richer in data types, which may allow for more accurate type conversion when exchanging data between languages.

[cderv]

Nice ! I think I'll make an example about that too as I think it is really good example use of arrow for cross language stuff. Thanks !

[marcobonici]

Is it possible to it the other way around? Define something in a OJS cell to pass later to a Julia one?
Ideally, i would love to have a slider to setup dinamically the value of a variable a using a slider and pass it to Julia.

Something like

```{ojs}
viewof l = Inputs.range([-2, 2], {
  value: 1, step: 0.01,
  label: "minimum fame"
})
make_variable_visibile(l = l)

using Plots
x = LinRange(0,10,10)
y = l*x
plot(x,y)

Thank you in advance!

[cderv]

I don't think you can do that. Simple reason is that Julia will run when rendering - this means you can't pass an interactive value set by user in your HTML output to be use by a Julia chunk. It requires more technical layer.

To do that, you need a Framework like Shiny for R or Python that will allow you to have content from UI impact computation from server, either a backend or in browser with shinylive.

We described this in OJS doc for passing by information to Shiny : https://quarto.org/docs/interactive/ojs/shiny.html

Without OJS there is also shiny itself:

• https://quarto.org/docs/interactive/shiny/
• https://shiny.posit.co/py/docs/shinylive.html
• https://github.com/quarto-ext/shinylive

Hope this helps find what you need