I had some students come ask me about implementing material from my numerical analysis course (which used Julia) in part of their Rust student group. I’m not an expert, but my feeling is that Rust is a “safer” language, which to me means it must be slower. That is, Rust is designed for “systems” where safety is more important than speed. Also, I believe the landscape for scientific computing packages in Rust is no where as developed as compared to Julia. Anyone with more experience with Rust know if my intuition is correct? I’d hate to be unnecessarily discouraging to students trying to be proactive.

I think I should recap what was discussed (as I understand it): The cost of bounds checking can be avoided in Rust by compile-time “proofs” of correctness, which are somehow done in the type system. There is also get_unchecked, which is unsafe. So I think the conclusion is that it is possible to achieve high performance in Rust. Rust does not have much in the way of interactivity. It wasn’t stated but it sounds like this would be hard to add due to the nature of static typing. However, its incremental compilation is fast so in many use cases this isn’t such a big deal. The array indexing syntax is not as nice as Julia. The package ecosystem is not as developed (no DifferentialEquations.jl, Flux.jl, etc.). Autodiff wasn’t discuss but I suspect it’s not as developed in Rust as in Julia. It’s possible to use Rust from Julia and vice-versa. I suspect this won’t work for passing in custom types, e.g. autodiff. The safety of Rust might hav benefits for a large scale scientific computing project, as it avoids bugs.

I am not claiming rust is more terse than Julia, but to be fair, you are rather comparing (std)libraries than the core languages. Note that rust‘s std is minimal by design. In rust you could also cheat like use random_string::generate; let alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; // or if you feel like it let alphabet = String::from_utf8( (b'a'..=b'z') .chain(b'A'..=b'Z') .chain(b'0'..=b'9') .collect(), ) .unwrap(); generate(30, alphabet) and the second example can be implemented as use rand; use rand::distributions::{Alphanumeric, DistString}; Alphanumeric.sample_string(&mut rand::thread_rng(), 30) There are probably other ways.

[image] Akatz: How do new generation static languages with type and function polymorphism guarantee performance without requiring a concretely typed entrypoint or call site? (rust, templated C++, Dex, Swift). C++ is like Julia. Templates aren’t checked except for instantiations. But having a few instantiations around your code will lead to those particular instantiations being checked. Other possible types might not work. Rust requires you specify traits for the arguments. If your generic function is function foo(a::A, b::B) c = bar(a, b) d = c - 3 d / a end you have to specify traits for A and B that make bar defined to return an object with a trait such that -(::typeof(c), ::Int) returns an object with a trait such that /(::typeof(d), ::A) is defined. Otherwise, you can’t compile the function. The IDE will give you helpful warnings telling you what is missing. Thus, foo will have to work for anything with traits A and B. If you define a new type and want to add trait A, the compiler will throw errors (telling you what is missing) until everything that trait requires is there. A can be a sum of many different traits, which makes it easier.

[image] Elrod: C++ is like Julia. Templates aren’t checked except for instantiations. This was later corrected.

I strongly agree with the desire for a tiered JIT. That is #1 on my compiler wish list. [image] goerch: This was later corrected. No. This is a powerful system of dispatch that would be great to have in Julia, but it is still like Julia in terms of (not) checking. Nothing is checked, other than the checks you add yourself. It is awesome that you can define a concept A that says foo(::A) returns Int, but then you can proceed to write the body of your function that dispatches on concept A without any checks or guarantees that A supports any of the body’s contents. # concept saying that `foo` must be defined on an `A` # and return an `Int`. # `floatmemaybe` must also be defined on `A`, too. `floatmemaybe(::A)` # can return anything that can be converted to `Float64` concept A = foo(A)::Int && floatmemaybe(A)::convert(Float64,..) function bar(a::A) # foo must be defined, and must return an `Int`, # because `a` satisfies concept A b = foo(a) # but we didn't say anything about buz!!! # Still, calling `buz` is okay in C++. Not in Rust. buz(a, b) end In C++ you can dispatch templates on what methods a type supports or basically any other property you can come up with, but that’s dispatch. It is also cool that this works with any number of arguments, i.e. you can dispatch on combinations of satisfying different concepts for each argument – it just has to happen at compile time (while Julia’s multiple dispatch semantically gets resolved at runtime). But the template body itself is not checked.

I am not sure, I understand your argument correctly. Maybe this article helps: No, dynamic type systems are not inherently more open ? tl;dr Statically typed languages with a proper™ type system can be as vague or concrete as necessary. In any case, you need to know something about a functions argument’s structure/properties to do something useful with it. Dynamic languages just happen to be implicit in their assumptions and tend to push checks into the runtime, whereas statically typed languages are explicit. My summary probably butchered the original article, so I urge you to read it instead.

Are you referring to something akin to Python‘s type hints that together with static linters like mypy introduce a gradual type system into python?

Maybe? I haven’t really thought it through, but it could be something like that. In a very vague sense, it just seems that Julia has ample syntax for type annotations/hints already, and I think if we just disallowed a few things, one could more or less treat it as a pretty strongly typed language already?

[image] cgeoga: an easier method for one-off scripts with deps (Sorry a bit off-topic below) I have just tried searching the net, and possibly this kind of things might help…? (I have no experience with it so not very sure it fits the purpose, though) Announcing cargo-single: conveniently build and run single-file programs with dependencies - announcements - The Rust Programming Language Forum Reddit - The heart of the internet The above thing seems similar to “dub” + single file in D: You don't need no stinking projects [dub version] - DEV Community

Yes, that is one approach, but it does not provide general compile-time bounds checking. It restricts what you can do so that the kinds of array access operations that cannot be checked simply cannot be used. You could certainly argue that this is fine, even desirable, since it can be handled by including appropriate checks in your code. But then, as Jeff points out, that user code amounts to a runtime check. And it has performance implications along very similar lines to Rust’s runtime bounds checking. If you’re in a situation where you’re willing to write unsafe code because you’re sure or pretty sure nothing will go wrong (maybe you’re relying on a sophisticated math theorem which is not readily communicated to the compiler), and the performance differences matter to you, then C++ lets you do that. That would not be possible in a safe language. In other words, there are some aspects of the safety-performance tradeoff which are fundamental, even though in many cases safety can actually improve performance, depending on the details of the problem (and the irreducible costs are in any case not very large).

Comparison of Rust to Julia for scientific computing?

Offtopic

Akatz March 28, 2022, 6:54pm 55

See my excerpts from Jeff’s thesis here @yonjuni : State of machine learning in Julia - #28 by Akatz

Topic		Replies	Views
Blog post: Rust vs Julia in scientific computing Offtopic rust	144	29565	December 18, 2025
Rust vs Julia Offtopic rust	11	33950	May 19, 2022
Julia stability vs Rust for Scientific Computing Optimization (Mathematical) question	43	4338	August 10, 2026
Julia solves a two-language problem but the real problem is a 3-wants problem which Julia does not necessarily serve well atm Community	36	5076	March 22, 2023
Does knowing Rust make you a better Julia programmer Offtopic rust	17	1273	November 17, 2024

Comparison of Rust to Julia for scientific computing?

Related topics