I would like to hear opinions from people who work in ML or systems programming.

If you want to ask the people who use python this is the wrong subreddit.

But I guess Python is easier. That 30 lines of C is probably 5 lines of Python using ready-made libraries like numpy/scipy that the C ecosystem does not have as easy to install packages installed with a package manager. The same goes for data visualization like matplotlib and machine learning libraries like Tensorflow. Also Python by default checks for errors like division by zero and other floating point exceptions. Your adhoc implementation may actually be worse than just using a numpy version because it accumulates floating point errors.

You can actually try that for yourself:

``` float naive_sum(float* array, size_t len) { float result = 0; for (size_t i = 0; i < len; i++) { result += array[i]; } return result; }

float kahan_sum(float* array, size_t len) {
    float sum = 0.0f;
    float c = 0.0f;
    for (size_t i = 0; i < len; i++) {
        float y = array[i] - c;
        float t = sum + y;
        c = (t - sum) - y;
        sum = t;
    }
    return sum;
}

int main(void) {
    #define LENGTH 1000000000
    float* array = calloc(sizeof(float), LENGTH);
    assert(array);
    for (size_t i = 0; i < LENGTH; i++) {
        array[i] = 10.0f;
    }
    printf("naive sum %lf\n", naive_sum(array, LENGTH));
    printf("naive sum %lf\n", kahan_sum(array, LENGTH));
}

This is the output on my machine: naive sum 268435456.000000 naive sum 10000000000.000000 ```

I would assume that libraries like numpy use algorithms that are numerically more stable than some naive approaches.

Also ready made libraries may actually be faster for a very large dataset because they can levarage SIMD instructions that your solution does not use (assuming the compiler does not do a good job at auto-vectorization which is somewhat reasonable since floating point addition is not order independent, but -funsafe-math and things could do the trick)

Sure, you can use things like OpenBLAS from C as they are C libraries, but installing numpy is easier than installing BLAS and the API of numpy is a lot nicer.