Hearted Youtube comments on Kantan Coding (@kantancoding) channel.
-
9
-
9
-
9
-
8
-
@kantancoding What I was saying is that comments provide "a" layer of guidance and confirmation, not "the" confirmation. Yes certainly, there should be test cases. But in practical terms, the struggles around not knowing which is wrong, the code or the comments/tests is still valid in both paradigms, whether you're taking about comments or tests cases.
Either way, when the bug report comes in, someone has to find the bug. When reading that code and wondering "hmm is this < supposed to be a <=", or "is this parentheses misplaced", or "is this parameter wrong", its much, much easier to read the nearby comments and gather the intent than to flip back and forth to another file elsewhere (like a test case) to try to figure out what the commentless "self documenting" code was supposed to do.
The part about "self documenting code can eliminate the need for most comments" is the fallacy. Sure, when you're the one writing the code, your own comments can look somewhat redundant. But that's cognitive bias coming from already understanding the code and whatever idea it was implementing. To someone else debugging that code their first time, those comments can be valuable.
The bandwagon of "self documenting code" and pressure to comment less seems to keep coming up as if its an answer, but it isn't. It's part of the problem, and its bad. Just like a dev who doesn't update comments is bad. I don't make excuses for either of them.
You are right in that comments can be poorly written. Writing good comments is a skill, just like coding itself is a skill. But someone else's poorly written comments aren't a validation to this movement of discouraging comments in the name of "self documentation".
8
-
8
-
8
-
8
-
8
-
8
-
8
-
8
-
8
-
8
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
7
-
6
-
6
-
6
-
I really need to say this. The advice to never nest your code has been repeated for years now, it's the same thing that I was told 8 years ago when I was reading about how to write VB code in highschool and it is a good concept, but It's important to note something.
In the provided example, yes, I think the code is easier to read, but it does not change the conditions you need to keep in your head. If you are doing more complex logic that then relies on the state of those conditions, you still need to know that those conditions are not true for example.
Take authentication. If you have middleware the runs in an endpoint, or your function verifies that the user is authenticated before running, you still need to know that condition has been met, otherwise you will end up writing redundant code in your actual logic to ensure that the user is authenticated. Whether your nest or don't nest the condition, you need to be aware of the state your app can be in at that point in the code, and both ways require you to have this awareness.
I agree that in most cases, early returns are better, but just wait until you have a function that has a structure like this and tell me it isn't confusing AF
if (A) return
// logic
if (B) return
if (C) return
// logic
if (D) {
//logic
} else {
//logic
}
if (E) return
//logic
The code looks readable, but damn, it can get confusing, especially if the code I put as "//logic" can potentially return, therefore adding conditions that aren't even ovbious. Sometimes the real solution in my opinion is to double up your conditions just for understandings sake, or in a complex case, abstract where necessary. The idea of code inversion is very primitive and does not always apply
6
-
6
-
Not that example specifically, but being able to treat functions as variables is amazing in general.
I wrote a differential equation solver for a university project once. There are lots of methods to do that numerically (approximating solutions) like Euler's method, AM2, AM3, AB2, AB3, BDF-2, and more. I could then implement one step function for each method, and one solve(...) function that took one of the step functions as an argument as well as initial conditions, and then it took steps until it was done. I think I even made it a generator, so I didn't have to save the entire list of potentially 100,000s of steps if I just wanted the max y value or something.
In general, it's a great tool to make template functions and separate out the specifics into their own functions.
6
-
6
-
6
-
6
-
6
-
6
-
6
-
6
-
6
-
6
-
6
-
6
-
6
-
6
-
6