How programmers comment their code

Same with BIOS descriptions.
FGTSAB switch [toggles the FGTSAB setting]
infuriating
- I love it
- It's so bad it's almost artistic
  
  You mean autistic.
- Yup, my first thought as well. While those days are thankfully over, those braindead BIOS "help" messages remain etched into my mind forever.
  
  Are the recent ones any better? I got a gigabyte b660m for 12th gen intel and it's really bad at that. Had to look up a lot to figure out things.
- Love having to enable "support for sleep state 5" to turn off USB power when the PC is off

Best comment ever was "It used to work like this but person at client demanded it work like that on this date" when the client complained it shouldn't work like that.
- That's basically what comments are most useful for. When you're doing something that's not obvious, and want to make sure the "why" doesn't get lost to time.
  
  // I'm not really that dumb, there is a reason.
  
  I spent a year making my company's iOS apps accessible (meaning usable for the blind and people with vision disabilities). I had to do a lot of weird shit either because of bugs in Apple's VoiceOver technology or because of the strange way in which our code base was broken up into modules (some of which I did not have access to) and I would always put in comments explaining why I was doing what I was doing. The guy doing code review and merges would always just remove my comments (without any other changes) because he felt that not only were comments unnecessary but also they were a "code smell" indicating professional incompetence. I feel sorry for whoever had to deal with that stuff at a later point.
- The best comments are "why" comments, the runner up is "how" comments if high-level enough, and maybe just don't write "what" comments at all because everyone reading your code knows how to read code.
- this seems like a great idea as it provides proof in writing just in case the stakeholder complains later on about the thing you implemented at their request
- That’s actually the perfect comment, because if anyone ever comes back to fuck with you about it, it’s explained right there. Then you turn it right back around on management and watch them run around like chickens with their heads cut off.
  
  Out management used to tell us, that even if head of department had committed to doing something some way, there's no way or need to hold them accountable. It's just that situation has changed, and nobody should bat an eye.
  To be fair, they also did not pressure us much for the missed deadlines or missing features, because it was indeed the result of the situation described in the first paragraph
- I was porting our old code from PHP to Go at a previous company. I laughed as I copied my then-six-year-old comment "I'm promised by xxxxx that this is a temporary measure
  <link to slack convo>
  ".

/* * Gets stupidFuckingInteger * * @returns stupidFuckingInteger */ public double getStupidFuckingInteger() { return stupidFuckingInteger; }
- The lack of a return type declaration makes this sooo good.
  
  It has the return type declared to be double.
- This being a double physically hurts
- Makes sense, people looking for int would find a double
  
  Happy cake day!
- Reminds me of a job I had where c# summaries were mandatory and people used a documentation generator just like that.
  /// Ages the Category. public int AgeCategory (...)

//@TODO document this function later
15 years later
- Have reviewed 16 year old code for a very well known company in the last week with this exact comment peppered throughout, alongside delightfully helpful comments like:
  // do not delete or change this it just works
  // TODO temporary fix added 12/09/11 to fix incident must be removed ASAP
  // CAUTION this returns false here instead of true like it normally does, not sure why
  // if true then matched to valid account not is true

Comments should explain "why", the code already explains "what".
- The allowable exception is when the what is a what the fuck, as in you had to use a hack so horrible that it requires an apology comment
  
  Absolutely, although I see that as part of why
  Why is there a horrible hack here? Because stupid reason...
  
  Describing the what also helps when you dabble in a new technology or little-used technology. It helps to explain to yourself what you’re doing and it helps in onboarding. “Hey, newbie, there’s a function in XYZ module that’s extensively documented. Look there for guidance.”
  
  Or if the what is so cryptic and esoteric that it would require the reader a couple hours of research to understand it.
  Also, I find it useful to summarise the what before code blocks if that can't be summarised in a function name
- Inline comments yes.
  Function/Class/Module doc comments should absolutely explain "what".
  
  You are absolutely right. It was inline comments I had in mind.
  
  I agree.
  I usually think of that as documentation, not comments.
  But even so, the code should say what it does, with a good name. The documentation adds details.
- Unless you're working with people who are too smart, then sometimes the code only explains the how. Why did the log processor have thousands of lines about Hilbert Curves? I never could figure it out even after talking with the person that wrote it.
  
  "Smart"
  
  If you know how the code does something, you also know what it does.

I had a old job that told me that code is "self documenting" if you write it "good enough". And that comments were unnecessary.
It always annoyed the heck out of me. Comments are imo more helpful than hurtful typically.
Is it just me? Or am I weird? Lol.
- Document intentions and decisions, not code.
- Code should always by itself document the "how" of the code, otherwise the code most likely isn't good enough. Something the code can never do is explain the "why" of the code, something that a lot of programmers skip. If you ever find yourself explaining the "how" in the comments, maybe run through the code once more and see if something can be simplified or variables can get more descriptive names.
  For me, that's what was originally meant with self-documenting code. A shame lazy programmers hijacked the term in order to avoid writing any documentation.
  
  lazy programmers
  I don't think they're lazy, I think they're not good writers. Not being able to write well is very common among programmers (not having to communicate with written language is one reason a lot of people go into coding) and in my experience the Venn diagrams for "not a good writer" and "thinks comments are unnecessary" overlap perfectly.
- Comment should describe "why?", not "how?", or "what?", and only when the "why?" is not intuitive.
  The problem with comments arise when you update the code but not the comments. This leads to incorrect comments, which might do more harm than no comments at all.
  E.g. Good comment: "This workaround is due to a bug in xyz"
  Bad comment: "Set variable x to value y"
  Note: this only concerns code comments, docstrings are still a good idea, as long as they are maintained
  
  Docstring are user documentation, not comments. User documentation, with examples (tests), is always useful.
- Its definitely a balance. Good code shouldn't need much commenting, but sometimes you have to do something for a reason that isn't immediately obvious and that's when comments are most useful. If you're just explaining what a snippet does instead of why you're doing it that way, there's probably more work to be done.
- Good code is self documenting as in you don't need to describe what it is doing and it is clear to read. Whoever says that and isn't just repeating what they heard understands that whenever you are doing something not explicit in the code it should be on a comment.
  Workarounds and explaining you need to use this structure instead of another for some reason are clear examples, but business hints are another useful comment. Or sectioning the process (though I prefer descriptive private functions or pragma regions for that).
  It also addresses the hint that the code should be readable because you're not going to have comments to explain spaghetti. Just a hint, doesn't prevent it. Others also said it, comments are easier to get outdated as you don't have the compiler to assist. And outdated comments lead to confusion.
- Code is not self documenting when decision trees are created based on some methodology that's not extremely obvious
- Code is the what. Comments are the why.
  Few things worse than an out of date comment.
- In my opinion, it strongly depends on what you're coding.
  Low-level code where you need to initialize array indices to represent certain flags? ~~Absolutely comment the living shit out of that.~~ → See response.
  High-level code where you're just plumbing different libraries? Hell no, the code is just as easily readable as a comment.
  I do also think that, no matter where you lie in this spectrum, there is always merit to improving code to reduce the need for documentation:
  Rather than typing out the specification, write a unit/integration test.
  Rather than describing that a function should only be called in a certain way, make it impossible to do it wrongly by modelling this in your type system.
  Rather than adding a comment to describe what a block of code does, pull it out into a separate function.
  Rather than explaining how a snippet of code works, try to simplify it, so this becomes obvious.
  The thing with documentation is that it merely makes it easier to learn about complexity, whereas a code improvement may eliminate this complexity or the need to know about it, because the compiler/test will remember.
  This does not mean you should avoid comments like they're actively bad. As many others said, particularly the "why" is not expressable in code. Sometimes, it is also genuinely not possible to clean up a snippet of code enough that it becomes digestable.
  But it is still a good idea, when you feel the need to leave a comment that explains something else than the "why", to consider for a moment, if there's not some code improvement you should be doing instead.
  
  Hard disagree on your first point. Name the flags with descriptive name, move this initialisation to a function, and there you go, self-documented and clear code.
- What they mean is that the variable names and function names are documentation.
  For example changing "for( i in getList() )" to "for( patient in getTodaysAppointments() )" is giving the reader more information that might negate the need for a comment.
- Have you ever worked in a place where every function/field needed a comment? Most of those comments end up being "This is the
  <variable name>
  , or this does
  <method name>
  ". Beyond, being useless, those comments are counter productive. The amount of screen space they take up (even if greyed out by the IDE) significantly hurts legability.
  
  And a good IDE let's you hide it so.... what is your point?
- I actually agree that "good enough" code can be self-documenting, but it isn't always enough to achieve my goal which is to make the code understandable to my audience with minimal effort. With that goal in mind, I write my code as I would write a technical document. Consider the audience, linear prose, logical order, carefully selected words, things like that... In general, I treat comments as a sort of footnote, to provide additional context where helpful.
  There are limits to self-documenting code, and interfaces are a good example. With interfaces, I use comments liberally because so many of the important details about the implementation are not obvious from the code: exactly how the implementation should behave, expected inputs and outputs under different scenarios, assumptions, semantic meaning, etc. Without this information, an implementation cannot be tested or verified.
- I absolutely agree, and I too hate this stupid idea of "good code documenting itself" and "comments being unnecessary".
  I have a theory where this comes from. It was probably some manager, who has never written a single line of code, who thought that comments were a waste of time, and employees should instead focus on writing code. By telling them that "good code documents itself", they could also just put the blame on their employees.
  "Either you don't need comments or your code sucks because it's not self-documenting"
  Managers are dumb, and they will never realize that spending a bit of time on writing useful comments may later actually save countless hours, when the project is taken over by a different team, or the people who initially created it, don't work at the company anymore.
  
  I've never had a manager that was even aware of the comments vs. no comments issue. If I ever had, I would have just told them that a lack of comments makes the original coder harder to replace.
- I follow these simple rules and encourage my colleagues to do so
  If I'm just shuffling jsons, then yes, the code should be self documented. If it's not, the code should be rewritten.
  If I implement some complex logic or algorithm, then the documentation should be written both to tests and in the code. Tests should be as dull as possible.
  If I write multithreading, the start, interruption, end, and shared variables should be clearly indicated by all means that I have: comment, documentation, code clearness. Tests should be repeated and waits should not be over 50ms.
- What a function does should be self evident. Why it does it might not be.

I write such comments because I have to.
Company policy.
Also we have to specify every line of code and what it should do.......
- Lol leave. That is so many levels of braindead.
- I would smash everything into a handful of overly-complicated lines.
  
  I loved doing this is school, just trying to mess up my teachers.
- // this line increments the value of i by 1
  i++;
  
  I hope they get paid per line of code.
- I feel like I am going to have to do the same thing in the end, to get my hand-over accepted.
  Should I just copy the line of code and make a comment next to it with:
  c++
  
  // It does <paste line of code>
  CC BY-NC-SA 4.0
  
  Do you license every comment of yours? If yes, why? Tbh i'm just curious

/********** Setting up the fkuArray **********/
fkuArray = array(...
- Well, fku that array indeed.

Comment about image
- answer: the answer

Good code is self-explanatory. You should only comment your code if it does something unexpectedly complicated.
That being said, it's always a good idea to write a manual, about how to use the code. Don't document how it works, because those who can code will understand it anyways, and those who can't, have no need to understand it.
- Good code is self-explanatory. You should only comment your code if it does something unexpectedly complicated.
  The code shows what is being done. The comments should explain the why.
  
  Yes. This 1000x. I hate it at work when I come across code that was written 3 years ago that has literally no traces of why it's there and a quick summary of what it does. Especially because that code is always the most abbreviated spaghetti you've ever seen. People should stop thinking (their) code documents itself because 99.999% of programmers cannot do it right.
  I really like the Google way of coding: assume the person reading the code is the most 1337 programmer ever, BUT that this person knows absolutely nothing about the project
  
  This is something a lot of people don't seem to understand. Even if code is self-explanatory, I want to know why it was designed that way.
  I've fixed bugs where the fix was only a one line change, but it was extremely difficult to figure out, so I left a 10ish line comment above it explaining why it has to be done that way.
- Hard disagree. It's a lot easier and faster to understand a function that is prefaced with a small line of text explaining what it does rather than trying to figure it out yourself.
  It's not about whether you can understand the code or not, it's about efficiency and clarity.
  
  Yeah, just 15 seconds and jot down a comment. Whenever I’m even hesitant, I just leave a comment. Doesn’t hurt anything and it can always be removed if not needed
  Easier to remove later rather than add it after the fact
  
  If done right, the "what it does" is in the method name. If your method is too complicated to summarize in its name, chances are good you should split it up or extract parts of it.
  
  Hard disagree - that's just dumb:
  
  // Calculates tax function calculateTax() { }
- Regardless, comments do speed up understanding.
- This is true, but it’s easier and faster to parse plain English and so if I don’t adequately comment my code the first time. I will be commenting it when I have to return to it for whatever reason. Honestly the second round of commenting is more verbose and clearer than the function x does y style of comments I tend to make when coding the first time
- Asinine business logic can still make some things very hard to read and digest no matter how well-planned and well-written it is (particularly if it is rushed by the business meaning that engineers don't have time to do it well). As such, there are places where code can't/won't be self-documenting to a useful degree.

The code is self explanatory
/s needed apparently
- The words of the machine are sacred, Only the impure need explanation
- It explains what it does, it does not confirm that it is what was intended.

Dankpods screen cap?
- I don't know. Anyway, DankPods is awesome, there's a great Lemmy community dedicated to his channel: !dingusland@suppo.fi
- Looks like it's from this old reddit post from 6 years ago: https://old.reddit.com/r/ProgrammerHumor/comments/8sviu4/code_comments_be_like/

A real comment in our junior year game engine codebase.
- visiblen't

How bad programmers comment their code. Good programmers don't comment at all and let the code speak for itself, leaving commenting to some obscure and arcane implementation the coder left in after a week long binge on caffeine and gummy bears.
- "What does this section of code do?"
  Run it and find out, coward.
  
  Nah. It should be obvious by just looking at it in code. If it isn't, you haven't extracted single purpose methods out of it yet.
- Code should absolutely speak for itself. But the occasional comment is still good to explain the 'why' of the code when the why isn't very obvious, often due to a niche requirement. Also any time you have to break out a hack, that needs comments up the ass, what was the bug, what URL did you find the fix at, why does this hack work, etc etc. It's very satisfying to go back and remove those hacks after they are no longer needed, often because the underlying technology fixed the bug that had to be hacked around.
  
  It definitely feels great when I get to remove the
  //hack abc due to bug in library xyz version 1.4.5, issue tracker says it's fixed in 1.5.0. - link
  
  Yeah, hence me mentioning the arcane code nobody knows what it does.
- This is the truth. In my experience, the people who often writes comments are also writing the most incomprehensible code.
  Comments are frequently getting outdated as well, so they’re not in great help understanding the code either.
  
  I was rewriting some old code of mine and ended up stripping out the comments. I kept reading them instead of the code, which I had been changing, and they were irrelevant. (I added new comments back in, though a big reason to rewrite was to make the code more self-explanatory.)

Our code base is filled with “//constructor”, “//destructor”, “//assignment”, or the ever enlightening “Foo GetFoo(); // GetFoo”.
This is not what they mean by self-documenting code.

Fs.?g??yy V>

I got a media failed to load error at first and thought that was the joke

At work we let Typescript and descriptive naming document our code. Only when something is a workaround or otherwise weird will we add comments. So far it has worked great for us.

this is why i very rarely comment with descriptive comments. If you're reading my code and don't understand what it is, even with how shit it is, you have no business reading whatever fucking crackpot shit im writing.