I actually had a fantastic experience with Fortran lately. I ported a compute kernel from python/numpy to Fortran 2018, partially due to the GIL and partly so I could use Intel's compiler. The performance improvement was tremendous. Several times faster per core, then multiplying further because I could take advantage of threading. In all, the 3 day project increased actual throughput 450x.

(I considered JAX, but the code in question was not amenable to a compute graph. Another option was to thread by fork, and use IPC.)

I liked the language itself more than expected. You have something like "generics" with tensors. Suppose you pass a parameter, N, and you also would like to pass a tensor, and you would like to specify the tensor's shape (N, N). You can do this; the parameter type constraints can reference other parameters.

Tensors and various operations are first-class types, so the compiler can optimise operations easily for the system you're building on. In my case, I got 80% improvement from ifx over gfortran.

Invocation from Python was basically the same as a C library. Both Python and Fortran have facilities for C interop, and Numpy can be asked to lay out tensors in a Fortran compatible way.

Part of what eased the port was that Numpy seems to be a kind of "Fortran wrapper". The ergonomics on tensor addressing, slicing and views is identical.

I did something similar many years ago. I was amazed that Fortran was not more discussed as an option to write performant code within a Python / numpy codebase.

At the time everyone seems to default to using C instead. But Fortran is so much easier! It even has slicing notations for arrays and the code looked so much like Numpy as you say.

Yea, Fortran is nice to use for so-called "scientific" computing. It has high performance as well as some handy intrinsic functions like DOT_PRODUCT and TRANSPOSE but the best features to me are colon array slicing syntax like Python/Numpy and arrays being indexed from 1 which makes converting math equations into code more natural without constantly worrying about off-by-one errors.

I wouldn't call multi-dimensional arrays tensors though. That's a bit of a bastardization of the term that seemed to be introduced by ML guys.

It wasn't until I started using Fortran that I realized how similar it is to BASIC which must have been a poor-man's Fortran.

If your problem fits into arrays/matrices/vectors as the only required datastructures, Fortran is a VERY good language.

> Suppose you pass a parameter, N, and you also would like to pass a tensor, and you would like to specify the tensor's shape (N, N).

You can do that, and it might be cleaner and less lines of code that way.

But you don't necessarily need to pass the array dimensions as a parameter, as you can call `size` or `shape` to query it inside your function.

    program main
      implicit none
    
      real :: a(2, 2) = reshape([1., 2., 3., 4.], [2, 2])
    
      call print_array(a)
    
    contains
    
      subroutine print_array(a)
        real, intent(in) :: a(:, :)
        integer :: n, m, i, j
    
        n = size(a, 1) ; m = size(a, 2)
        write(*, '("array dimensions:", 2i3)') [n, m]
        do i = 1, n
          do j = 1, m
            write(*, '(f6.1, 1x)', advance='no') a(i, j)
          end do
          print *
        end do
      end subroutine
    
    end program

I've never found anything to back this up, but my impression was that both the Python / Numpy and Fortran 90 slicing operations were directly inspired by MATLAB (although most of the ideas go back to at least Algol 68).

It also helps that Fortran compatibility is a must for pretty much anything that expects to use BLAS.

Any reason why you couldn't do this in C/C++? I use the Eigen matrix library as a replacement for Numpy when I need more performance and the code looks surprisingly very similar.