[mr_mitm]

Why not just do something like this then? This:

    myfunction(data) {
        # do one thing to the data
        ...

        # now do another
        ...
    }

becomes that:

    myfunction(data) {
        do_one_thing_to_the_data(data)
        now_do_another(data)
    }

    do_one_thing_to_the_data(data) {
        ...
    }

    now_do_another(data) {
        ...
    }

Still linear, easier to get an overview, and you can write more modular tests.

[ropejumper]

Because now you have to jump around in order to see the sequence of events, which can be very frustrating if you have to constantly switch between two of these functions.

Plus, if we're dealing with a "long list of tasks" that can't be broken up in reusable chunks, it probably means that you need to share some context, which is way easier to do if you're in the same scope.

One thing I find useful is to structure it in blocks instead, so you can share things but also contain what you don't want shared. So e.g. in rust you could do this:

    let shared_computation = do_shared_computation();
    
    let result_one = {
        let result = do_useful_things();
        other_things(&shared_computation);
        result
    }
    
    ...

I think it's a nice middleground. But you still can't write modular tests. But maybe you don't have to, because again, this is just a long list of tasks you need to do that conceptually can't be broken down, so maybe it's better to just test the whole thing as a unit.

[quietbritishjim]

Instead of, say, 10 functions in a file that are all individually meaningful, you now have maybe 50 functions that are mostly tiny steps that don't make much sense on their own. Good like finding the "real" 10 functions buried amongst them. It's certainly higher cognitive load in my (painful) experience.

[rocqua]

If the arguments to the function required are small, then breaking such a block down makes sense. Otherwise, it usually feels like an unnatural function to me.

[tugu77]

We have different ideas about what "linear" means.