CODEWITHSUNDEEP
algorithmperformancelanguage-agnosticreadability
Naci
Naci

Reputation: 231

Passing the same variable through intermediate methods which don't directly process it

More than often I find myself passing a variable into a method, where it is not directly used, but is yet passed to another method for further processing. I don't know if there is a name for this practice either. I can explain it better with a sample code:

static void main() {
    int a = method1(var1, var2, var3)
}

int method1(int var1, int var2, int var3) {
    var4 = some_function_of(var1, var2)
    return method2(var3, var4)
}

int method2(int var 3, int var4) {
    return some_other_function_of(var3, var4)
}

This case can be expanded where there the same variable (var3) is passed through even longer chains of methods. I think this could be a bad practice, as in my example method1 is some sort of intermediate that is not manipulating var3. Is there a better practice for performance, design and/or readability?

Upvotes: 2

Views: 63

Answers (2)

Andrew
Andrew

Reputation: 518

This is not at all uncommon and not necessarily a bad practice. It can impact all three of the metrics you mentioned though:

  1. Performance: Adding another parameter to a function call may result in a performance hit but not always. It depends on the language, compiler/interpreter, and platform. For example, an optimizing compiler for C++ will try to avoid copying a variable even if it is passed by value if it can (sometimes it will eliminate a function call completely). But passing a value through multiple functions might mess up the compiler's optimizations if it can't follow the path well. Still, I expect any performance hit from this to be minimal.

  2. Design: Depending on your language's paradigm (object oriented, functional, etc...) this might indicate that your design could be improved, perhaps by encapsulating the data in a structure or class so that only one parameter is passed (a class instance pointer) and each function accesses only the class members it needs.

  3. Readability: This shouldn't make the individual functions harder to read, since they shouldn't care where parameters come from and it is clear that the parameter is being passed to another function. It could make it harder to understand the whole program though because it can be hard to keep track of where values originate if they are passed through a long chain of calls before being touched.

In general, it is good to minimize the parameter list (for all of these reasons) and to keep data "closer" to code that needs it. If you do those things, this case shouldn't pop up much and when it does it will be less likely to be due to bad design.

Upvotes: 1

GhostCat
GhostCat

Reputation: 140467

At least for object oriented languages the answer would be:

  1. You definitely want to avoid such code - as you struggle to reduce your parameter list to the absolut minimum; the goal is zero.
  2. If you find that your class should offer various methods that all require the "same" parameter; than that makes that parameter a candidate to be a field within your class.

In non-oo languages, I think you have to pragmatically balance between having more functions and parameter list length. In your example,

static void main() {
  int var4 = some_function_of(var1, var2)
  int a = method2(var3, var4)
}

avoiding method1 ... saves you passing var3 to your first method. And you are still within the rules of the "single layer of abstraction" principle.

Upvotes: 2

Related Questions