[Paper Review] Towards new solutions for scientific computing: the case of Julia

M. Tomasi, Mosé Giordano|arXiv (Cornell University)|Dec 4, 2018

Scientific Computing and Data ManagementDecision Sciences3 citations

TL;DR

This paper evaluates Julia as a high-performance, expressive programming language for scientific computing in astronomy and astrophysics. It demonstrates that Julia achieves C/Fortran-level performance through Just-In-Time compilation and loop fusion while supporting interactive development via Jupyter notebooks, enabling efficient data analysis and simulation of large-scale astrophysical projects like CMB space missions.

ABSTRACT

This year marks the consolidation of Julia (https://julialang.org/), a programming language designed for scientific computing, as the first stable version (1.0) has been released, in August 2018. Among its main features, expressiveness and high execution speeds are the most prominent: the performance of Julia code is similar to statically compiled languages, yet Julia provides a nice interactive shell and fully supports Jupyter; moreover, it can transparently call external codes written in C, Fortran, and even Python and R without the need of wrappers. The usage of Julia in the astronomical community is growing, and a GitHub organization named JuliaAstro takes care of coordinating the development of packages. In this paper, we present the features and shortcomings of this language and discuss its application in astronomy and astrophysics.

Motivation & Objective

• To evaluate Julia's suitability for scientific computing in astronomy and astrophysics.
• To assess Julia’s performance and usability compared to established languages like Python, C++, and Fortran.
• To explore Julia’s capabilities in handling large-scale data workloads and interactive analysis.
• To identify key advantages and limitations of Julia in scientific workflows.
• To demonstrate practical applications of Julia in simulating space missions and processing astronomical data.

Proposed method

• Leveraging Julia’s Just-In-Time (JIT) compilation and type inference to achieve high runtime performance.
• Using Julia’s native array operations and loop fusion via dot syntax (e.g., .+ ) to optimize numerical computations.
• Employing homoiconicity and the Zygote package for automatic symbolic differentiation at compile time.
• Integrating external libraries via ccall and wrappers (e.g., PyPlot.jl, FITSIO.jl) to interface with C, Fortran, Python, and R.
• Rewriting monolithic C++ codes into modular Julia components for interactive use in Jupyter notebooks.
• Benchmarking Julia performance against existing C++ and Python/Numpy codes on large-scale data simulations (e.g., CMB mission timelines).

Experimental results

Research questions

• RQ1 Can Julia deliver performance comparable to compiled languages like C and Fortran while maintaining high-level expressiveness?
• RQ2 How effective is Julia’s loop fusion and JIT compilation in accelerating numerical and array-intensive scientific computations?
• RQ3 To what extent can Julia replace monolithic scientific codes with interactive, modular, and maintainable alternatives?
• RQ4 What are the practical limitations of Julia in scientific workflows, particularly regarding compilation time and ecosystem maturity?
• RQ5 Can Julia enable efficient, interactive analysis of large astronomical datasets, such as those from space missions?

Key findings

• Julia achieves performance within 10% of optimized C++ codes when simulating data timelines for CMB space missions.
• Julia’s loop fusion via dot operators (e.g., .+ ) enables single-loop execution, matching Fortran’s efficiency and outperforming NumPy’s multi-loop approach.
• The Celeste project processed 178 TB of SDSS data in 14.6 minutes across 8192 nodes using Julia, demonstrating scalability on large datasets.
• Julia’s integration with Jupyter notebooks allows interactive exploration of parameter spaces, significantly improving workflow flexibility compared to monolithic codes.
• Compilation times in Julia can be a bottleneck when calling many short functions, making some interactive scripts slower than equivalent Python or interpreted code.
• The lack of standalone executables and a mature library ecosystem remain key challenges for deployment and adoption in production scientific workflows.