วีดีโอ

Saying Julia is not good for anything outside of simple scripting seems to me that some doesn't actually know how to program in Julia. I have written at least 2 large simulation packages ( phontonics related.) They were previously written in C for speed. Julia is just at fast as the C ones and and way easier to maintain and extend. I was able to model then optimize the code so much easier than c or c++. I think think you just don't have experience writing a large package in Julia. That is not to say Rust isn't a good language. Rust seems to be a good systems level programing language. Julia is not. Plain simple has nothing to do with size of the program.

based

3:49 the rust code is measuring the creation of the list & transformation, while in Python & Julia he is only benchmarking the transformation... so silly

5:10 Note the "ss" at the end, which stands for scalar single(-precision float). This code is processing one element at a time and just happens to use AVX/FMA instructions to do it. You want "ps" (packed single), which is the SIMD version of the instructions.

Great presentation.

ك

Very nice! great example.

Nice work

wow faer seems real fast

I think this is a great snippet of the issues of Julia; there are of course a lot of other issues (starting with the fact that it indexes at 1). I definitely agree that Julia does not solve the two language problem; right now mojo is the best candidate to solve it, but mojo's decision to essentially be compatible with python will be a huge albatross in this endeavor. Ironically, I do think that Rust comes closest to solving the two language problem, it is much easier to do scripting/prototyping in rust that to get a quality prod-ready code in Julia.

Why the hurry in the end :( those were interesting examples

Isn't Option more appropriate than Result for noting whether the search found something or not? Edit: it was asked at the end :)

Watched with interest. Graph theory and row/column permutations of equivalent sparse matrices is a very important topic in computational numerical analysis, making use of Dulmage-Mendelsohn decomposition, Tarjan's algorithm, early work by Roger Sargent, and many others in the field. These all in some way or another involve searches with backtracking. The goal is generally to permute the rows and columns of a sparse matrix to achieve a result with more useful structural properties. Is this field orthogonal to your work, does it intersect with it, and might any of your work equally be useful in numerical analysis?

What on earth is this channel

Really nice talk!

thanks for sharing this, wondering if you explored julia before?

This is pretty cool

sovler

Why not OpenCL for GPU?

1:48 HTTP/1.0 was 1996, HTTP/0.9 was around for several years before that.

Bayes and rust, two of my favorite topics

Awesome work!

Faer seems great but the documentation is a nightmare!

I want a lua vs julia comparison pls😊

This is an old debate. Bottom line: developing in Julia is and will be easier. Rust is an amazing compiler, but developing code in Rust seem to be a PITA.

Thanks for the talk and for the video!

never have i ever seen v.pop used or taught in julia. the use case would be someone trying to straight up paste code from some other language to julia.

I have been waiting for something similar forever!

what about software development efficiency? how easy the language for researcher or scientist to adopt the language? code readability? personally, for scientific computing, I don't think rust is anywhere close to julia/python or even matlab or R. I love rust for its speed and safety, but a lot of rust enthusiasts want others to see it as the "best language for everything" which is just clearly wrong.

Shame it was hurried at the end - thanks for the talk Miguel really useful insights

The guy using godbolt might be using a different compiler toolchain, or may be compiling for windows, which is why he got a different output.

I have learned both rust and julia around the same period last year and tried right away to implement them in a serious research project. My experience was that the rust ecosystem is still a bit underdeveloped. Here few examples: 1) to do efficient linear algebra, you must interface with low level BLAS and LAPACK calls, which must be implemented in an unsafe region of code and are very conterintuitive to use. 2) The tools for nuneric optimization of function are a bit outdated, depending on old version of the ndarray causing a conflict of types when used with new versions of the library (at least one year ago) 3) write performant and vectorized code require a lot of skills in the language, also not much support for GPU computing and large scale multiprocessing with message passing interface (MPI) across multiple nodes, where multithreading is highly inefficient. 4) It is extremely challenging to quick prototype an idea and to transform the prototype in a production code without rewriting. Now, it is possible that it was a skill issue from my side, but I found in julia a very efficient way to go for my huge project (and I learned julia exactly at the same time). It is way easier to pickup, and the support for scientific computing comes out of the box. Then when I discovered the Automatic Differentiation, my life changed. I work a lot with optimizations, and not having to derive and implement the expression for gradients means a huge time saving (often months of work). Then the multiple dispatch makes it so easy to extend and plugin the code that it is really a pleasure. Sure, the absence of GC and memory safety of rust are very nice, but I do not see it to be competitive in the scientific computing area.

8 minutes and he had to rush in the end… Sad

Give the guy 2 hour slot to talk!

Guys, use the right language for the right problem... Rust is the language you want for writing stable and performant software for sure. Noone would want to write a database in Julia, but for scientific computing, Im sorry, Julia is just the better language. There are static analysis tools for Julia as well you dont need a compiler for that. Btw you can have bad performance in any language if you dont know basics.

At the end he suggests to use Julia in user cases that are mostly solved by Python (interactivity, prototyping and plotting). I think is unfair. I have not used Rust in a real app, but I have read and done some tutorials and it is quite more dense than Julia, and if you change the logic of your code you might need to propagate that change across you code in a very annoying way, specially with types. Not very friendly for prototypes. C++ has not the memory safety warranty offered by Rust , but scientific and numerical programming are usually not big codes with very intensive loops and very few objects with simple life cycles. Threads and parallelism can be somewhat nicer in Rust but Julia also makes then easier to use, but there is nothing like optimized OpenMP for Rust. In my view Rust is great for complex apps or libraries with low-level optimization. So I see people in sci comp using Rust in the same way as people use C/C++/Fortran: as compiled libraries for a Python script. That is my case, as I have been using Polars, a very good dataframe library, in my python scripts. Julia is great for simulations that might be longer that a few minutes. The REPL is great for using try and error to test the code, and optimizing and scaling the code step by step. However the JIT lag is awful. Even the LSP server (made in Julia) without any caching took more than a minute to compile and start. There is hope for better times lately but I will wait a bit for that promise to materialize. Python is instantaneous in comparison. And with good vectorized code and numba and JAX it can be very fast. So Julia only is a good option for scripts that would take more than 30 minutes to run. Simulations of physical systems are a good case for Julia, as they usually fall in that category. Data science is usually tables of less of 1 Gb., so Python works great for that. Tables of larger than 10 Gb are usually handled on the database, or in server side virtual machines, and the python libraries are more mature for that case, or Spark with scala is widely used in the industry. Julia only has a chance in the 1Gb to 10 Gb data sizes, but Polars probably destroyed that chance. So Julia is not bad but it is sort of stuck in a niche in simulations and Bayesian simulation (probabilistic programing). Neural networks could have been a good killer feature, but Python and Numpy API was dominant alreardy and research and effort went into Python. Torch was initially Lua, and they move to Python. And with that pressure Python has been getting faster. Mojo is in the horizon, but I am eyeing it from afar to see if the hype delivers. So I am not very hopeful about Julia growth.

Hi, i'm learning about bayesian statistics now ... and will need to use the emcee package to do MCMC for regression analysis. It looks like Lace does a lot of stuff ... looks amazing ... i could use it over emcee? (i'd like to use Rust over Python ...)

"Promo sm" 🤭

amazing !

Hi, very interesting crate with lots of potential. Do you have extended documentation for Lamellar online anywhere? Thank you.

I couldn't get the rust code example to compile. I ended up with this, in order to get it to run: use rayon::prelude::*; fn main() { let x: Vec<i32> = vec![1, 2, 3, 4, 56, 89]; let y: Vec<i32> = vec![5, 6, 7, 8, 65, 98]; let a = 2; let sum: Vec<_> = x .par_iter() .zip(y.par_iter()) .map(|(&x, &y)| y + a * x) .collect(); println!("{:?}", sum); }

I don't think Julia has many "performance footguns". To me a footgun is something that is easy to get wrong. Does Julia allow non-performant, non-type stable, etc things? Yes. I have yet to see Julia code that is very slow where I am wondering why it isn't fast. The example given of a Array{Any}, it is obvious to me why that wouldn't be performant. To me Julia's advantage is that it is a language where it is "easy to get performant and idiomatic code". You can not care about performance at all and get code that runs slow (but you can write fast). You can, if you want, make very optimized code that looks nothing like idiomatic Julia. In most cases I want something in the middle. I want abstract idiomatic code (easy to maintain) that is reasonably fast. I've found avoiding things that make your code slow in Julia is usually easy and there are nice tools for doing so.

Is the BB code available on Github?

Thanks for the presentation.

Nd arrays in rust suck. Lack of elegant broadcasting rules also sucks. No way to generate cuda kernels (from within rust). Lack of a good AD/ML library. I dont know what kind of scientific products you are using rust for, but definately rust is not the tool for my usecase.

4:28 I think pop! is a feature. Most of the time, if I try to pop an empty array, I want my program to error so I can know there was something wrong.

Great talk

🎉🎉🎉