OK, I get your point about coupling. But I am not sure why you consider high coupling to be a bad thing, especially in case where you have an automated refactoring system.
It seems to me that to "decrease coupling" you have to add nodes to dependency graph, and this increases overall complexity.
Perhaps you could provide some example where high coupling (calling different functions from a single function) is bad, and how would you like to have it resolved.
Update: Actually, with automated refactoring, you wouldn't have to modify any existing functions (except maybe to call your new functions). You would just write new functions that would incorporate the new functionality using perhaps the existing building blocks. Then the refactorer would sort out things in DRY manner, as needed. So you don't need to care if the code is easy to refactor, it just needs to be easy to read.
Isolation of code enables you to more easily understand it, test it, replace it and re-use it.
Linear increases in coupling leads to a combinatorial explosion in the difficulty in all of the above.
Coupling is actually more important than DRY.
I don't understand how you imagine you can "isolate code" while making it less DRY. If I need to do certain functionality from some function, I need either to call other function to do it (if you already have a function that can do it) or copy that functionality into the function itself. The first approach is DRY, the second isn't. But I don't think second approach is a good idea, like, at all. So if I assume you don't mean that, what do you mean?
I can understand you can make code easier to test if you make it less DRY. Let's put that aside, because it's not really a big deal in this discussion. But the other three - I would love to see some specific example where making code less DRY will increase ease to understand it, and also possibly replace it and re-use it (provided we don't care about elegance of the result, since it would be taken care of by subsequent refactoring, as I already explained, so we can for instance copy-paste the existing code for the purpose of change).
It isn't a different function, but "send_email" is better than "send_message" which is in turn better than a function just called "x" which is shorter. In each case a different metaphor is used. x is a shorter method but code that uses names like that everywhere is NOT cleaner. It's horrible.
>Not quite. The important thing to understand is that I am not optimizing for size of a single program, but large set of different programs.
Optimizing purely for size will end up increasing coupling to an insane degree. I've seen this done by people who get religious about DRY.
>Well, I understand "high coupling" differently than you, then. For me, it means things like doing different unrelated things in a single function (so the result is that it's harder to reuse it). It doesn't mean that you cannot call other functions.
If you're using one function to call another you have coupled them.
Coupling is not about what you can or cannot do it's about what is.
Coherence (or rather, a lack thereof) is about doing different things in the same function (or class, file, project, etc.).