Naming a function that compute a thing - naming-conventions

Question

Consider a Python module (but it is relevant to other language) with a series of functions meant to be used sequentialy.
Namely, functions are semantically linked according to the following scheme:
def function_a_to_b(thing_a):
"""Compute the thing_b."""
thing_b = thing_a**2
return thing_b
def function_b_to_c(thing_b):
"""Compute the thing_c."""
thing_c = thing_b**3
return thing_c
In this trivial example, a candidate name for function_a_to_b could be squaring and thing_a could be named square, and likewise we could use cubin and cube.
Now if thing_a is something complicated that does not support verbing, say a weighted_glonk.
How can I name function_a_to_b to keep things short, obvious, and avoid variable clash or error prone namespace subtleties?
I incline towards compute_weighted_glonk for the function. Another option is hungarian naming, say array_weighted_glonk for the thing

Answer 1

It depends what you want to do with that glonk, but you are mostly right with compute_wighted_glonk. If you want to compute him, then name that function compute_glonk(), if you want to get his name, the function would probably be get_name_of_glonk(). Lot of people will have lot of suggestions, there are lot of ways to name your functions. Was my answer enought?

Answer 2

If it is a complicated thing that doesn't support verbing, then i would suggest to create a class for it and create the thing by the constructor.

Answer 3

My advice is to find a balance between short and verbose in naming --Dmitri Pavlutin
Don't be afraid to use an auxiliary word. In plain english you wouldn't struggle with "The plant growthed..." but simply go with "The plant presented growth...".
Back to your example like cube/cubing you may write glonk/obtainGlonk or glonk/calculateGlonk.
Also, focus on the readability more than keeping the verbing standard which at the end of the day is what the fellow programmer will read. Your verbed word, is what, an effect? Keep it that way.
Your action should describe a change that has happened in your system

Answer 4

My fifty cents: I would argue against introducing naming conventions to reveal computational structure (Robert Martin: "We have enough encodings to deal with without adding more to our burden" [Clean Code, p.23]). If your functions are meant to be called in a strict order, you should encapsulate them in another function that does precisely that; or create some kind of latch, if that's approriate.

Answer 5

I don't know python, so I'd like to answer from javascript perspective. I can't figure out what you mean by a glonk and something that does not support verbing in programming context. thing_a can, at most be, as complicated as another array,object or another callable function -- in those cases you can put type checks in function_a_to_b. Also, Compute the thing_b can be replaced by another function if it involves multiple operations. What I would do is the following:
//I'm using $ for var names just for semantics.
//$var is a php usage but I want to emphasise
//what things are variables.
function myComputer($thing){
if(typeof($thing) == ("object")) {
//take total no of properties or whatever you want
return Object.keys($thing).length;
}
else if(typeof($thing) == ("number")) {
return $thing;
}
else if(typeof($thing) == ("string")) {
return $thing.length;
}
else {
return 0;
}
}
function mySquarer($a) { //sementic naming instead of function_a_to_b
var $b = Math.pow(myComputer($a),2); //In your original version whats the point of computing thing_b if you wanna reassign a different value afterwards?
return $b;
}
function myCuber($b) { //When you call myCuber you can do myCuber(mySquarer($anything));
var $c = Math.pow(myComputer($b),3);
return $c;
}
console.log(mySquarer(3));
console.log(myCuber(mySquarer(2)));