This Overly Long Variable Name Could Have Been a Comment | Jonathan's Blog (jonathan-frere.com)

submitted 1 day ago by shape_warrior_t@programming.dev to c/programming@programming.dev

32 comments fedilink hide all child comments

Thoughts? It does feel like there's a lot of things you can do in comments that would be impossible or impractical to do in names alone, even outside of using comments as documentation. There's certainly much more information that you can comfortably fit into a comment compared to a name.

One of the comments in the Lobste.rs post that I got this from stuck out to me in particular:

Funny story: the other day I found an old zip among my backups that contained the source code of game that I wrote 23 years ago. I was just learning to code at the time. For some reason that I forgot, I decided to comment almost every single line of that game. There are comments everywhere, even for the most obvious things. Later on, I learned that an excess of comments is actually not considered a good practice. I learned that comments might be a code smell indicating that the code is not very clear. Good code should be so clear, that it doesn’t need comments. So I started to do my best to write clear code and I mostly stopped writing comments. Doing so only for the very few parts that were cryptic or hacky or had a very weird reason for being there.

But then I found this old code full of comments. And I thought it was wonderful. It was so easy to read, so easy to understand. Then I contrasted this with my current hobby project, which I write on an off. I had abandoned it for quite some months and I was struggling to understand my own code. I’ve done my best to write clear code, but I wish I had written more comments.

And this is even worse at work, where I have to spend a ton of time reading code that others wrote. I’m sure the authors did their best to write clear code, but I often find myself scratching my head. I cherish the moment when I find some piece of code with comments explaining things. Why they did certain things, how their high level algorithm works, what does this variable do, why I’m not supposed to make that change that looks like it will simplify things but it will break a corner case.

So, I’m starting to think that this idea that comments are not such a good practice is actually quite bad. I don’t think I can remember ever reading some code and thinking “argh so many comments! so noisy” But, on the other hand, I do find myself often in the situation where I don’t understand things and I wish there were some more comments. Now I’m trying to write comments more liberally, and I think you should do the same.

I guess that’s a generalization of the op’s idea.

top 32 comments

sorted by: hot top controversial new old

[-] zygo_histo_morpheus@programming.dev 4 points 9 hours ago

I try to write comments whenever what the code isn't obvious on its own. A "never write comments" proponent might argue that you should never write code that isn't obvious on its own, but that doesn't always work in practice

Sometimes you have to write cryptic code for performance reasons
Sometimes you have to deal with unintuitive edge cases
Sometimes you have to work around bugs in 3rd party code
Sometimes you are dealing with a problem that is inherently complex or unintuitive, no matter how you put it in to code

[-] silasmariner@programming.dev 4 points 2 hours ago

Sometimes you just need to document the business reason behind what you're doing, regardless of how clear the code might be 😆

[-] TehPers@beehaw.org 4 points 9 hours ago

Sometimes you are using language features your team is unfamiliar with.

Had this happen before with pattern matching.

[-] HaraldvonBlauzahn@feddit.org 4 points 11 hours ago

More people should try out literate programming. It is very powerful, especially for complex code and software you want to maintain in the long run.

[-] silasmariner@programming.dev 1 points 20 minutes ago

Literate programming as an ideal works at very very high level and very very low level. Plumbing code often doesn't benefit from comments at all, and is the usually the most subject to refactoring. Code by amateurs/neophytes is often not gonna be written in such a way that a clear description of the intention or mechanics is achievable by the coder. Unobtainable standard, smh. I like comments with a 'why' at the top and a 'what' at the bottom (of the stack. I'm talking about abstraction layers. Why am I doing this piece of logic in the code you can clearly understand at the top, what the fuck am I doing these weird shenanigans with a fucking red-black tree of all things in this low level generic function)

[-] Zacryon@feddit.org 3 points 13 hours ago

I don't like code, that isn't well documented. In fact, this has been my main source of frustration in the past and required the most time to deal with. Thousands of variables, hundreds of thousands of lines of code, how am I supposed to go through it somewhat fast, if there aren't any comments or pieces of documentation that are guiding my understanding? I can't spend half a year to just get a grasp of how the code works.

Comments (as well as docstrings and readmes etc.) provide higher level overviews that can guide you through the code rather quickly, even if it may be longer in terms of words or character count than the lines of code it describes, it may accelerate understanding tremendously. It's just a lot more effort to trace each variable and see what it does and how it interacts with others. This can quickly become exponentially hard to track.

I don't think it's necessary to comment each line of code, except in rare cases or maybe when setting up a class and describing the members and roughly how they're used,, but a few words here and there, at some higher or intermediate level, roughly describing what you want to do, can go a long way for others (and even yourself, when working on a project for several years). It's also already sufficient to just highlight the most important variables in a piece of code, when explaining it. Given that info, this steers your focus when reading the actual code.

"Speaking" variable/function/... names are also very useful. I don't care if it's a long name, as long as it's sufficiently expressive. E.g. "space_info" instead of "si". This helps to understand the code more quickly and reduces backtracking lookups, because you already forgot again what a specific variable does that you haven't seen for a while. My rule of thumb for variable naming: As consice, short and "essence grasping" as possible, but as long as necessary.

[-] TehPers@beehaw.org 6 points 18 hours ago* (last edited 18 hours ago)

Ah yes, one of the major questions of software development: to comment, or not to comment? This is almost as big of a question as tabs vs spaces at this point.

Personally? I don't really care. Make the code readable to whoever needs to be able to read it. If you're working on a team, set the standard with your team. No answer is the universally correct one, nor is any answer going to be eternally the correct one.

Regardless of whether code comments should or shouldn't exist, I'm of the opinion that doc comments should exist for functions at the very minimum. Describe preconditions, postconditions, the expected parameters (and types if needed), etc. I hate seeing undocumented **kwargs in a function, and I'll almost always block a PR on my team if I see one where the valid arguments there are not blatantly obvious from context.

[-] vermaterc@lemmy.ml 30 points 1 day ago

The biggest problem with comments is that they can become outdated. If you change code but forget to change comment you introduce very dangerous situation where they become not only not useful, but also misleading.

If you rely on variable names, you've got a single source of truth, one thing to change at a time. Information updates itself.

[-] squaresinger@lemmy.world 2 points 5 hours ago

Symbol names can be outdated as well, but what's worse is they can be flat-out wrong.

Real-life example that I had at my last job:

var isNotX = isX()

// somewhere else in the code:

var isX = isX()

fun isX() {
  // Code returns isNotX
}

That part of the code had a bug and it wasn't clear whether the function should return X or not X (the function was much more complex but returned a boolean).

A comment could have given context and/or be used as parity check for which implementation would have been correct.

This way I had to step through the whole flow just to figure out what it's doing and what it's supposed to do.

[-] vermaterc@lemmy.ml 0 points 4 hours ago

Everything comes down to proper function naming. If it wasn't clear what function should return, then it was not named properly.

[-] tatterdemalion@programming.dev 11 points 1 day ago

You say that like it can't also happen to symbol names.

[-] Derp@lemmy.ml 3 points 14 hours ago

With symbol names it's trivial to notice and refactor. Comments, not so much.

[-] Pyro@programming.dev 6 points 1 day ago* (last edited 1 day ago)

Tbf, old comments can also give important context through earlier refactors and help avoid treading the same ground again.

That being said, this is with the assumption that the next dev making a change will add their own comments describing it.

[-] ulterno@programming.dev 3 points 1 day ago

One big reason for requiring comments being updates the same time as what is commented. I once managed to do that for a while when I alone was making and maintaining a project.

It becomes harder, the more people are working on a project and the larger the project gets.

But the alternative would lead to Java-like function-etc names and that is not very desirable either.

[-] towerful@programming.dev 6 points 1 day ago* (last edited 1 day ago)

I feel like variable or function names that become overly verbose indicate that a specific type or a separate class should be considered.
I see it as a mild code smell.

Something like int intervalSeconds = 5 could maybe have a type that extends an int called seconds. So then you are declaring seconds Interval = 5.
It describes the unit, so the variable name just describes the purpose.
You could even add methods for fromMinutes etc. to reduce a bunch of (obvious) magic numbers elsewhere.

To extend this contrived example further, perhaps there are a couple of intervals. A refresh, a timeout and a sleep interval.
Instead of having.

int sleepIntervalSeconds = 0;
// etc...

You could create an intervals class/object/whatever.
So then you have.

public class Intervals {
    public seconds Sleep
    public seconds Refresh
    public seconds Timeout
}

The class/object defines the context, the type defines the unit, and you get nice variable names describing the purpose.

[-] squaresinger@lemmy.world 4 points 14 hours ago

Tbh, creating new code just to shorten variable names is pretty bad practice. Don't do that.

Each line of code needs to be maintained, each line of code can contain bugs and reusing such a class in locations it wasn't actually made for can cause more harm than good.

And if you are adding external information (e.g. via a class) why not just add that information as inline documentation (aka comments) instead? Most IDEs can handle that so that if you hover over the variable/function name it will display the documentation. And pretty much all IDEs allow you to navigate to declaration with just one click, and there you find the necessary information.

You example only gets worse if you keep nesting these things, so for example if I have:

int sleepIntervalSeconds = 0;

Then I immediately know:

It's an int (not a double)
It's an interval used for sleeping
It's in seconds

(Putting all that in a comment instead of the variable name is almost equally as visible via IDE)

Instead consider your proposal, which would read like this:

Intervals var.sleep = 0;

I used var as the variable name since you abstracted the informations "sleep", "interval" and "seconds" into other definitions.

So now I still know it's an interval used for sleeping, but both the real variable type and the information that it's in seconds is gone. I have to navigate to the Intervals class/type to figure that out.

IRL this often gets even worse, because Intervals probably doesn't even contain the fields directly, but instead inherits from a Time class, which then inherits from some other class, and then you might get to the actual definition of the field.

This is only amplified by using Mixins and other obfuscation goodness.

If you have two options, and one option creates extra code, extra classes and extra code paths without reducing the complexity of the code significantly, than that's the worse option.

[-] towerful@programming.dev 2 points 11 hours ago

Yeh, my example was pretty contrived and very surface level.
It grouped things that seemed related at a surface level but weren't actually related at all. Which makes it a bad example.
And realistically, you would use a timer class that raised events, and passed in an interval class that could be constructed from any appropriate units.

It was more to highlight that types and classes are a fairly easy way to improve the context around variable.
It can also use type checker to show incorrect conversions between minutes and seconds, Polar and Cartesian coords, RGB and HSV, or miles and kilometers. Any number of scenarios where unit conversions aren't a syntax error.

[-] squaresinger@lemmy.world 2 points 10 hours ago

I know it was just an example, and examples are always contrived. It was just a good example to show how complexity can increase a lot if you use classes/types as glorified comments.

This total denial of the existence of comments, which is a common attitude right now, can easily do more harm than good, when you add code not for functionality but instead just to have more space for symbol names to put text into.

The project I worked on in my last job suffered a lot from this. It would lead to some really weird patterns, like e.g. this:

class BaseCommand {
    var commandType
}

class CreateCommand extends BaseCommand {
    public CreateCommand() {
        this.commandType = CREATE;
    }
}

We had dozens and dozens of classes that didn't actually contain any actual code, but were just flavour for "readability", which in turn just created garbage lines of code and all that trash would negate any potential benefits to readability. And since the code was spread out over so many classes it would mean that even simple changes would require touching tons of files.

I had, for example, a very simple 1 Story Point task to do. The whole task was "rename a variable", nothing more than that. I had to change 40 files. Not an exaggeration, it really was 40 files.

Code is for code, comments and external documentation are for documentation. Don't abuse one for the other.

[-] thingsiplay@beehaw.org 9 points 1 day ago

But this can lead to over engineering simple stuff. Which makes the code harder to read and maintain and more error prone. Especially if you don't need all the other stuff for the class. Worse, if you define a class then you also tend to add more stuff you don't use, just in case it might be useful.

A simple variable name is sometimes the better solution. But it depends on the situation off course. Sometimes a new class make things more clear, as it abstracts some complexity away. Yeah, we need to find a balance and that is different for every program.

[-] TehPers@beehaw.org 3 points 18 hours ago

This depends. Many languages support 1 liner aliases, whether that's using/typedef in C++, type in Rust, Python, and TS, etc.

In other languages, it may be more difficult and not worth it, though this particular example should just use a duration type instead.

[-] towerful@programming.dev 3 points 1 day ago

Yeh, absolutely.
Horses for courses.

[-] dudinax@programming.dev 2 points 1 day ago* (last edited 15 hours ago)

This relatively new. Only "recently" (last couple decades) was it easy to get type info for a variable where it was used.

The other problem is that if your type is merely an alias, in many languages you can still do

interval_minute = interval_second

without the compiler catching it.

[-] NABDad@lemmy.world 12 points 1 day ago

Later on, I learned that an excess of comments is actually not considered a good practice.

Pointless or uninformative comments are not good, regardless of the quantity.

Useful and informative comments are always good, regardless of the quantity.

I learned that comments might be a code smell indicating that the code is not very clear.

When I'm looking at someone else's code, I want to see extensive, descriptive comments.

Good code should be so clear, that it doesn’t need comments.

That hits me like something a teacher tells you in a coding class that turns out to be nonsense when you get to the real world.

I'm not sure how others do it.

As I'm coding, the comments form part of my plan. I write the comments before the code. As I discover I've made incorrect assumptions or poor decisions, I correct the comments with the new plan, then correct the code to match the updated comments.

As a final step in coding, when I feel it is complete, I'll review comments to determine what should remain to help future me if I ever have to dig into it again.

Variable names should be reasonably memorable and make contextual sense, but that's it. That's what they exist for. Don't overload the purpose of anything I'm the code.

[-] vermaterc@lemmy.ml 5 points 1 day ago

That hits me like something a teacher tells you in a coding class that turns out to be nonsense when you get to the real world.

In a company I work in, we have "no comments policy" for at least ~10 years now and we are not planning to change that. It's not just theory, we work like this in practice and purpose of each part of code is perfectly understandable just from variable names, file names, namespaces, function names.

[-] sxan@midwest.social 2 points 1 day ago

// Increment i
i++;

Very info. Much useful.

[-] squaresinger@lemmy.world 3 points 14 hours ago

Congratulations, you figured out to do comments the wrong way.

You also figured out how to use a bad, unclear variable name, so should we also stop naming variables with sensible words since it can be done wrong?

External documentation can also be done badly, so let's stop doing that too.

Or what's your point?

[-] thedeadwalking4242@lemmy.world 2 points 20 hours ago

Something’s you leave out but let’s say instead you are using some enumerator like in Python over a list of some objects. Sure you can use “i” but what if it’s a list of apples then why not make the iterator “apple”

For Apple in apples

Simple example but the concept can go a long way

[-] Flamekebab@piefed.social 21 points 1 day ago

I find vague variable names exhausting. It adds not inconsiderable mental overhead when reading code, at least for me.

[-] spidertrolled@lemmy.blahaj.zone 8 points 1 day ago

You can write comments, but you can't make your colleagues read them. They don't necessarily have to visit the originating file to read the docs.

Short variable names tend to lead different people to make different kinds of assumptions about the purpose and use of the variable. Those differences in understanding is where a lot of subtle bugs come from, or causes people to hit a dead end.

Just be clear and explicit. Its not gaming; you dont have to care about losing a couple extra frames to type out a few extra characters. Most IDEs have sufficient autocompletes so it's literally not even a problem in many cases.

[-] squaresinger@lemmy.world 2 points 14 hours ago

You can write comments, but you can’t make your colleagues read them. They don’t necessarily have to visit the originating file to read the docs.

When do you need documentation? When you are down in the code or when you are sitting on the toilet browsing Confluence? If your goal is to make people read the documentation, then the documentation needs to be immediately there where you need it, not in some external thing like Confluence.

Same goes with if your goal is to make people update the documentation. That's much more likely to happen if the documentation is in a comment in the code than when you first have to go hunting to find the correct page in that steaming pile of mess that is confluence.

Just be clear and explicit. Its not gaming; you dont have to care about losing a couple extra frames to type out a few extra characters. Most IDEs have sufficient autocompletes so it’s literally not even a problem in many cases.

You still only got so much screen real estate, and having huge names means that your lines get very long at times, which makes everything really hard to read.

[-] thingsiplay@beehaw.org 4 points 1 day ago

My rule of thumb is, use short names if the context makes it clear. But do not make names too long and complicated (especially with Python :D). For me having unique names is also important, so I don't get confused. So not only too similar names are bad, especially if they all start like "path_aaa", "path_bbb" and such, then the eye can't distinguish them quickly and clearly. And searching (and maybe replace) without an IDE is easier with unique and descriptive names.

Sometimes its better to come up with a new name, instead adding a modification and make the name longer. This could be in a for loop, where inner loops edit variables and create a variation of it. Instead adding something like "_modified", try to find what the modification is and change from "date" to "now" instead "date_current".

[-] Blackmist@feddit.uk -2 points 1 day ago

Nothing wrong with a, i, s and x.

this post was submitted on 03 Jul 2025

86 points (94.8% liked)

Programming

21357 readers

324 users here now

Welcome to the main community in programming.dev! Feel free to post anything relating to programming here!

Cross posting is strongly encouraged in the instance. If you feel your post or another person's post makes sense in another community cross post into it.

Hope you enjoy the instance!

Rules

Follow the programming.dev instance rules
Keep content related to programming in some way
If you're posting long videos try to add in some form of tldr for those who don't want to watch videos

Wormhole

Follow the wormhole through a path of communities !webdev@programming.dev

founded 2 years ago

MODERATORS

snowe@programming.dev

Ategon@programming.dev

MaungaHikoi@lemmy.nz

UlrikHD@programming.dev