PyCall.jl

> nice foreign function interface between R->Julia and Julia ->R JuliaCall[1] and RCall[2]. Python<->Julia is similarly well exercised with PyCall[1], and recently PythonCall[2]. [1] https://non-contradiction.github.io/JuliaCall/index.html [2] https://github.com/JuliaInterop/RCall.jl [3] https://github.com/JuliaPy/PyCall.jl [4] https://cjdoris.github.io/PythonCall.jl/stable/

PythonCall [1] and PyCall [2] provide pretty convenient ways to interoperate with Python from the Julia language. It has great package/environment management, excellent (potentially close-to-C) performance, automatic type inference, and a good set of interactive tools that make for a rich REPL. But any such FFI (from any language) is an additional point-of-failure, an extra gear that could break and has to be maintained. And on the con side of Julia, there's an initial compilation time (which is improving version to version, but still a factor to consider). Also it should be mentioned that the advantage of Python is not only its ecosystem of libraries, but also the vast array of tutorials and learning resources, and of development tools. Those are areas where most other languages have to play catch-up with Python, especially a relative n

There's a package for using R libraries (https://juliainterop.github.io/RCall.jl/stable/) and one for Python libraries (https://github.com/JuliaPy/PyCall.jl). It's pretty seamless.

For Julia there's pycall: https://github.com/JuliaPy/PyCall.jl I believe there's one for the opposite direction as well.

The ecosystem is a superset of Pythons: https://github.com/JuliaPy/PyCall.jl

Julia has a package that does this fairly elegantly (not perfect of course, but you can wrap on top of this) https://github.com/JuliaPy/PyCall.jl.

> I'd love to use Julia and Rust instead, but the ecosystems and users aren't there yet. https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaInterop/RCall.jl

Julias interop with Python is excellent: https://github.com/JuliaPy/PyCall.jl (also with R, see RCall.jl). It's just not statically typed, so the original problem is not solved - albeit Julia being the better language for scientific purposes. CL could also be great language-wise (https://digikar99.github.io/py4cl2/, https://github.com/snmsts/burgled-batteries3) but I don't know how good the interop is in reality since I haven't tried it.

I actually don't know very much about how it works (which is a testament to the usability of the libraries!) I use PyCall to use Python from Julia, and PyJulia to do the reverse. PyCall & PyJulia have functionality to easily share arrays. PyCall is pretty seamless, PyJulia is a bit more work but still solid. To share a DataFrame, I convert it to Arrow, get a bytearray representation of that, use PyCall/PyJulia to access the array from a different process, and reinterpret it as Arrow data within that process. PyCall: https://github.com/JuliaPy/PyCall.jl PyJulia: https://pyjulia.readthedocs.io/en/latest/

It's possible to use it in a Julia-like fashion (like PyCall.jl[1]). For example, with OCaml one could use Pyml[2]. [1] https://github.com/JuliaPy/PyCall.jl [2] https://github.com/thierry-martinez/pyml

There's nothing wrong with using the tools you know. But IMO it's quite interesting to use languages that might just be a big improvement over how things have been done so far. I think Julia is such a language when compared to Python (excluding the ecosystem, of course). Also, if you come back to Julia sometime there's this: https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaInterop/RCall.jl

> The ecosystem is still pretty barebones compared to Python There's help: https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaInterop/RCall.jl Works like a charm.

For Julia there are PyCall and RCall, so the ecosystem is less of an issue than with other languages. Also, its ecosystem has been growing quickly over the last 2 years or so. https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaInterop/RCall.jl

I worked with R and Python during the last 3 years but learning and dabbling with Julia since 0.6. Since the availability of [PyCall.jl] and [RCall.jl], the transition to Julia can already be easier for Python/R users. I agree that most of the time data wrangling is super confortable in R due to the syntax flexibility exploited by the big packages (tidyverse/data.table/etc). At the same time, Julia and R share a bigger heritage from Lisp influence that with Python, because R is also a Lisp-ish language (see [Advanced R, Metaprogramming]). My main grip from the R ecosystem is not that most of the perfomance sensitive packages are written in C/C++/Fortran but are written so deeply interconnect with the R environment that porting them to Julia that provide also an easy and good interface to C/C++/Fortran (and more see [Julia Interop] repo) s