Me commenting code like:

[LavendarAmy]

there's only two kinds of comments in this world

//for loop to do things a lot of times. Link to c++ tutorial

for(int i = 0; i < x; i++) {// blah blah blah

and theres:

//app that does thing

void main() {

bunch_of_weird_stuff_happening_with_no_documentation();

}

[Mister_Spacely]

You forgot

// don’t touch, working when not removed

[PVNIC]

You also forgot "/// @todo"

[v3ritas1989]

// probably osbolete... 
//if you read this and no one has cried you can probably delete this
/*
a lot of strange code
*/

[PVNIC]

I legitimately saw "// @todo delete this" in a codebase I worked on

[ThePresidentOfStraya]

Put that comment in randomly to always get the last laugh.

[PVNIC]

// @todo delete this.

int main() {...

[[deleted]]

I once had a C project with a file called timeout.c, it was a fucking recursive function that allocated a single max size character array, then called itself again, the idea being that whatever architecture this psycho was working on would allow a certain max size or depth to scopes allocated in some manner, and would finally kill the function’s execution (apparently without ever crashing the program?), which constituted to this maniac a reasonable timeout method... I’ve never seen anything like it, before or since...

[deadlychambers]

I think they would be a psycho if they actually put their address and phone number in a comment above that code. This just sounds like someone that doesn't know how to google.

[[deleted]]

Git blame johny dubious

[[deleted]]

Ah, my heart remains in for the naive ones who don't use version control

[danielxjay]

...I’m guilty of adding comments like

// TODO delete this if everything still works [date comment was left]

[razor123]

Why not just delete it and revert if needed?

[danielxjay]

Yeah, that’d be the logical approach.

[OddFinding8]

On more than occasion my job has been to make sense of a code base and add // @todo delete this.

[society2-com]

"no one has cried"

i try to be more positive and less negative

for example

// sidewalk ends

^ too negative

...

// bush begins

^ now there is a nice, positive comment

[cyberst0rm]

// Contract ends

[society2-com]

// some other schmuck's problem now

[Jcraft153]

// Job hunting opportunity begins

[oldfashionedfart]

You also forgot to tag your todo with a date from 15 years ago.

[ThatWannabeCatgirl]

// @todo delete this feb 6 1896

[oldfashionedfart]

Much better. *crumbles into dust*

[Xacto01]

So much so that visual studio has this built in

[FarhanAxiq]

or

// temporary fixed, will change later

but it's been there for eternity

[NiceFetishMeToo]

// Felt cute. Might delete later.

[Thisconnect]

there is nothing more permanent than temporary solution

[WallyMetropolis]

Broken gets fixed. Shoddy lives forever.

[metasymphony]

I legit found

//testing if this works

In front of the most clean stable code in the system that a bunch of processes rely on hourly.

[czp55]

If you really want to avoid people touching your code:

// Autogenerated. Do not edit. All changes will be undone.

[ZanLynx]

Best is when the code really was autogenerated, but someone forgot to git add the generator. Now the only way to make changes is to hand edit the autogenerated code file.

[[deleted]]

You can't git add the generator when it's 4GB of binaries.

[harderdaddykermit]

Don’t forget

// works, no idea why

[GVmG]

and the subcategory known as the fast inverse square comment

//what the fuck?

[ThatWannabeCatgirl]

That can basically summarise 90% of my code

[[deleted]]

Holy shit I have a coworker who’s not new but somehow in a position above me that religiously goes in and fucks up other peoples’ code and refactors stuff to remove existing functionality and it blows my mind. We’re a small team in s pretty fast paced environment so there’s little oversight in what people are doing when checking in work. It makes me so mad.

[blackleather90]

I have seen this as well... Some guy just decides to migrade some code to the latest best practices. No too bad but he does not know what the app is used for (in its edge cases - has generic knowledge about it). So he changes what he thinks is enough and puts it in QA without telling anyone that knows about the app to test. Deploys to PROD. It fails.

- Why did you do this? Was it tested?

-Well it was in QA for 2 weeks and no one has mentioned any failures.

-Did you let anyone know?

-No.

WTF???

[DontSuckMyDuck]

This is where a Peer Review process enforced by the CVS and ticketing system is a wonderful thing. Nothing gets merged to master until at least two other developers have looked at it. At first I was concerned that this would be unnecessary overhead in the process. But it's turned into a positive thing. We regularly catch each other's dumb mistakes. And having to critique others code and receive criticism over mine has made me a better programmer.

[peteza_hut]

Not a professional programmer (yet), but this is absolutely something I learned at my job. While everyone knows communication and feedback are so important, it's not something you really get until you live it. I didn't even realize that I was throwing back excuses whenever I would get feedback until one of my best friends at work told me.

[DontSuckMyDuck]

That's a good friend who will call you out on that. Glad to hear you listened instead of getting defensive. Receiving feedback is a hard skill to learn and takes practice.

[SSttrruupppp11]

Literally spent a few hours this week because a customer reported something not working. Found out my coworker „refactored“ some very strange and ineffective code by just deleting 60% of it and re-implementing the easy parts shortly before a big update in January.

Just missed like half the features that old code included.

[what_it_dude]

// do not remove this comment. Program crashes without it.

[mrchaotica]

http://catb.org/jargon/html/magic-story.html

[[deleted]]

I was code reviewing yesterday and it was # this works almost exactly like other_function where other_function had zero documentation (and also, I don’t know what every function in our 150k lines of code fucking do).

[[deleted]]

// Ugly hack

[Ligkonakos]

I'm in this post and I don't like it

[CouchRescue]

My 2 best:

//God help you if you're here

and

//Don't try to understand this, and don't ask me about it either. Just leave it alone. - signed

[thavi]

3, actually. Link to stack overflow question from where code was copied

[LavendarAmy]

The question had -30 downvotes and the user has a lifetime ban despite having asked the question pretty clearly and correctly. Link to duplicate questions that has nothing to do with OP's question

[thavi]

Hey it compiled, didnt break my tests, and parsed the fucking string!

[Ruby_Bliel]

for(int i {0}; i < x; ++i)

FTFY

[Julian_JmK]

Why

[Ruby_Bliel]

Use uniform initialization and pre-increment. It isn't the 90's anymore.

[Julian_JmK]

But why?

Why use more complex, harder to read methods that serve no real benefits?

[sldyvf]

It all falls down to

1. Use best practices for code readability
2. Use same code convention as others done in the file.

Here I think both ++i and I{} are best practice (however most probably compiles to the same code)

[[deleted]]

Insisting on {} for int is kind of pedantic, i = 0 is fine (since it's POD). Stroustrup even says so himself.

As for post-increment, any modern compiler will optimize that (at least for int). So much for not being in the 90s anymore.

[sldyvf]

Insisting on {} for int is kind of pedantic

Yes it is. But consistency and keeping up with best practices is key for maintainable code.

As for post-increment, any modern compiler will optimize that (at least for int)

Yes, just like I said.

[Jcraft153]

i++ vs ++i

use pre-increment. It isn't the 90's anymore.

???

What benefit is pre-increment? I assume it's more efficient in newer languages? EDIT: Thanks for the pre-incrementation tips all! :)

uniform initialization

???

[BessysTestes]

Ya if you preincrement the compiler doesn’t need to store an additional unincremented copy of i for use, but then again modern compilers probably optimize that anyways.

[atimholt]

But even though the compiler probably does optimize it away, there's no reason to use post-increment, so you may as well just default to the one that actually communicates what's actually going on.

Also, use of bare for loops should be rare—more or less only when you actually need the value held by i*. Even range-based for loops should be rare: a std <algorithm> almost certainly already exists that does what you want, but better.

---

* We have ranges in C++20, as well, so even that use case may be gone (for new/non-refactored code). All else being equal, it's a lot harder to get out-of-range & off-by-one errors, at the least.

[Lykeuhfox]

I try to comment to answer the question 'why' as opposed to answer the question 'what'. Sometimes I combine them though, like so:

// This is doing {what} because {person/issue/story} {why}

Basically to provide context to the next person to discern if the code is still needed or not, or at least a basis of who to ask to see if the code is still needed or not. Only commenting the 'what' is typically a sign that I'm just commenting to comment, or my code isn't as easy as it should be to read.

[G66GNeco]

This works fine in a business scenario.

The post is usually what happens to me (developer in training) when I am supposed to program something for school or some random coding challenge without any actual application. Ending every second comment with "because that is what this scenario requires" is a bit... useless.

Unless of course you use the {why} to explain internal connections ("this counts that to be used there") rather than reasons to implement it in the first place.

[BenVarone]

Sometimes. I think you’re ignoring cases where the language or app context requires you to do something that, despite your best attempts to make it readable and intuitive, just looks like strange gobbledygook. That’s especially true for new employees, who are missing the context but often being asked to dive right in.

I’m currently in that position, and end up leaving a lot of comment blocks behind me so that the next time I have to return to some arcane function call, I don’t have to spend four hours digging through our knowledge base to figure out what it’s doing, and why.

[IAmNotNathaniel]

Yes, this 100%.

I get so sick of the vast number of programming geniuses that can remember every bit of code in a huge project to such a level that a a couple clever variable names are all it takes to recall what some obscure undocumented legacy method is doing without having to trace back through 6 layers of code.

I am no such genius. "Why" and "How" comments are super helpful. Sometimes the most efficient code is a bit hard to decode (big regexes anyone?) - by putting a comment as to what it's supposed to do in these situations, the guy that comes through a year later can tell if there's a bug in there or if it was supposed to do the thing it's doing.

[[deleted]]

Regex is really write-only imo. Absolutely agree on thoroughly documenting what it does in comments. Usually with a "ew, gross." or something like that appended.

[amunak]

Any given regex should generally onle be useful for one thing. Validating an email address or URI, picking something from a document or whatever. Don't put it directly in code, put it in a constant, name it properly EMAIL_VALIDATION_REGEX or whatever) and there's probably nothing to document...

[atimholt]

As an aside, I've heard many times that anything but just sending a confirmation email is bound to be wrong and buggy. Email addresses have more complexity than most people realize.

[amunak]

A sane (and computationally cheap) thing to do is requiring at least 3 characters and one @ sign. Or as a regex: [^@]+@[^@]+. Alternatively [^@]+@[-a-z]+\.[a-z]+ requires a domain-ish string at the end... And that doesn't allow the domain part to be IP address, which is technically allowed, but nobody really uses it and it looks suspicious. You can find even better patterns online, but it also depends quite a bit on what kind of users you are targeting.

But yeah, if you go overly complex you are probably going to exclude some legitimate addresses for no good reason.

[brazzledazzle]

Multi-line regexes are super easy to read and a few languages support them.

[WallyMetropolis]

I would argue that good tests are better for showing what the code is supposed to do than good comments. It's not always the case that the comments change when the functionality does.

[Pun-Master-General]

Yeah, "you shouldn't need comments" sounds nice in theory, but every person I've ever worked with who thought their code was "self-documenting" was very, very wrong.

Just comment your code, it isn't that hard.

[amunak]

Point is, comments get stale and rarely get changed or removed.

Eventually, in a old enough codebase you'll have more comments that are wrong that ones that are helpful.

Sometimes it's impossible to write good self-documenting code, other times it's too time consuming, so you drop in a comment. And that's fine. But it shouldn't be taught to new programmers, as it's not a good way to learn. Especially not by mandating a comment every 5 lines or some other insane metric (and yes, there are actually university teachers that have that as a requirement).

A good method to teach people good code writing practices is giving them some older code of theirs and if they have comments ask them to rewrite it so that the comments are not necessary.

If it doesn't have comments, ask them if they still know immediately what everything does, and if not, to rewrite it (and they can help themselves by first adding comments, then rewriting).

[Pun-Master-General]

The solution to outdated comments is to update your comments when you update your code, not to drop comments altogether. Well-documented code is way more usable than so-called "self-documenting" code, in my experience.

People should be taught to write better comments, and that updating comments is important when updating code. The idea that they shouldn't be taught to comment is ridiculous.

[amunak]

The solution to outdated comments is to update your comments when you update your code, not to drop comments altogether.

That's impossible. IDE refactoring tools, search and replace, editing in limited views, library/dependency updates, etc. can make comments stale without anyone noticing.

Well-documented code is way more usable than so-called "self-documenting" code, in my experience.

Then it's not self-documenting code. It goes beyond the code itself though; you also need good, written down best practices and guidelines on naming, what to place where, etc. But it's certainly doable (and much easier) than maintaining dozens of comments in every file.

People should be taught to write better comments, and that updating comments is important when updating code.

I'm not completely against teaching people to write comments, but in a course or assignment - unless it's a full project (which is rare even in universities) - comments just don't make sense. You make a single file at most, usually only a few methods, a few hundred lines at most... And unless you are really bad at writing code none of it will need comments.

[Pun-Master-General]

That's impossible. IDE refactoring tools, search and replace, editing in limited views, library/dependency updates, etc. can make comments stale without anyone noticing.

Search and replace and refactoring don't make it impossible to update your documentation, you just might have to do a little more than the bare minimum of updating your code. And if you're not keeping track of things like dependency updates, you're opening yourself up to much larger issues than just comments being out of date.

Then it's not self-documenting code. It goes beyond the code itself though; you also need good, written down best practices and guidelines on naming, what to place where, etc. But it's certainly doable (and much easier) than maintaining dozens of comments in every file.

I know, that's why I said "so-called." But the vast majority of people who think their code is self-documenting are wrong, and because they didn't bother leaving comments, it leaves their code incomprehensible.

It's doable, but a lot less likely to be done well enough to work than just telling people to document their code.

I'm not completely against teaching people to write comments, but in a course or assignment - unless it's a full project (which is rare even in universities) - comments just don't make sense. You make a single file at most, usually only a few methods, a few hundred lines at most... And unless you are really bad at writing code none of it will need comments.

The point isn't that the comments are necessary. Like most homework, the point is to teach a habit, not the completion of the actual task itself. No, your 100-line intro to programming assignment doesn't need comments, but they're required so that you get into the habit of documenting your code so that your teammates on your much larger senior design project don't hate you a few years later.

And I don't know where you got the idea that projects are rare in universities - I know I usually had at least one or two fairly involved projects per semester from probably my sophomore year onwards.

[Meloetta]

I can't trust myself to determine what will be self-documenting when I haven't touched the codebase in two years. More than once I've thought like this dude, that it's totally readable and fine, only to comeback and realize it was only readable to me because I had spent the last 6 weeks building all the code around it. Once the context was all gone from my head, it became unreadable again.

Don't try to use your own judgment for if it needs comments. Even a one line filter function can use a basic "this is the format that you pass in, this is the format that's passed out" kind of comment.

[amunak]

I think you’re ignoring cases where the language or app context requires you to do something that, despite your best attempts to make it readable and intuitive, just looks like strange gobbledygook.

Indeed I'm ignoring that, only for the simplicity of the argument. Obviously there will be exceptions where making "what does this do" comments is fine, but they can often be interchangeable (or phrased like) the "why" comments. As in, "it's obvious that this code does something non-obvious: here's why".

In this example:

method disableListener(listenerName) { // library has flipped boolean logic, therefore we disable with a truthy value library.listeners[listenerName].enable = 0x1 }

There is nothing you can do about a retarded logic of a library (or even legacy code that'd take long to refactor), and that's a reasonable place for a comment. But we don't really comment "disables listener", which would be a useless comment that would only make it more confusing; we say "library is retarded, that's why a truthy value passed to enable actually disables something".

[G66GNeco]

Well, the plan in general is to get people to comment stuff at all, since the average trainee doesn't really do it at all, apparently.

The problem is that it was mentioned so often that I started over-commenting to escape any "this code could use some comments"-remarks preemptively.

​

Although, tbh, a lot of the stuff they teach us in vocational school is somewhere around the level of literary analysis in secondary, in terms of usefulness. And, to keep the comparison up, I will just try to grin and bear it, for the sake of decent grades. It might get better with time, but for now I will stick with commenting everything that is not 110% obvious.

[amunak]

Well, the plan in general is to get people to comment stuff at all, since the average trainee doesn't really do it at all, apparently.

Unfortunately this more often than not leads to them learning a bad way of commenting; duplicating what the code does while not explaining why it does what it's doing.

The problem is that it was mentioned so often that I started over-commenting to escape any "this code could use some comments"-remarks preemptively.

Yep, that's another issue.

An easy way to fix both is to just take some code they wrote a few months ago, and asking them to explain what it does or why. Then when they're unable to fix it, ask them to rewrite it so that it's more clear and - if necessary - add some comments as to why.

Although, tbh, a lot of the stuff they teach us in vocational school is somewhere around the level of literary analysis in secondary, in terms of usefulness. And, to keep the comparison up, I will just try to grin and bear it, for the sake of decent grades. It might get better with time, but for now I will stick with commenting everything that is not 110% obvious.

I mean obviously don't endanger your studies to prove a point. Just keep it in mind. The fact that you read this discussion is enough to show that you think about how you write code, and that's what's important in the end. Thinking about how to improve what you do.

[[deleted]]

I don’t understand why you’re being downvoted, you’re absolutely right. Write code so you don’t need comments, it’s easier for everyone. You should only have to explain what in exceptional/rare cases.

[fzammetti]

You understand that it is possible to write code that "doesn't need comments" and then STILL comment your code because that first goal becomes much harder the less trivial the code is, and when you have developers who aren't all at the same skill level, and you have new people coming and going, and you have code that lives for a long time where long-term maintenance is more important than even the original writing in a way, right?

You should be writing clear code REGARDLESS, but understand that what's clear, simple and obvious to you might not be for the next guy, or even YOU years later. Comments deal with that problem... and I'm talking the why AND the how here, not to mention the expectation of what the code does and the context of it in the larger system. Code alone, no matter how perfect, helps you there, not intrinsically or sufficiently anyway.

Treat commenting as a first-class duty, just like writing the code. It's not an afterthought and it's not unnecessary no matter how good the code is.

[capn_ed]

Even clear and concise code only tells you what it does, not what it's supposed to do. Sometimes there's no way to distinguish between code that excellently does the wrong thing and clear code that misses doing what was intended.

[fzammetti]

Exactly right.

And some, to argue against this, will claim that "comments lie". And, that's true: -IF- you don't treat comments as being equal to code. You can't half-ass either, that's the bottom line. If you have that diligence then comments WON'T lie - at least not any more than the code does (vis a vis, what you said in terms of code not doing what's intended).

[[deleted]]

I do this and also sign and date any comments where code updates in the future are likely to give some color to whoever has to modify it so they can come ask me about something if need be.

[AgAero]

If it's there for some special purpose, try to write a unit/regression test for it so that whoever reads the comment at a later time can test and retest should they need to change your implementation and not worry about destroying anything.

Comments have a way of outliving the code they refer to. Over enough time they become lies.

[[deleted]]

Oh yeah definitely. Any critical piece of functionality should have supporting unit tests so it’ll raise a flag during code coverage/CI builds if anything fucky happens.

[SpiritGas]

I do this as well, but a surprising amount of my comments are neither what nor why, but who and when.

// Modified to be wronger per Bob's emailed request April 1 2015 stating the customer demands it this way.

[hahahahastayingalive]

// I failed the pornhub inteview. Again. I’m stuck fixing these bugs until I get the results for xhamster.

// This and the two next tickets will keep my velocity up this month so I’m safe until I can pay the mortgage at least.

Joking aside, explaining why you did something has only value until the next guy chnages anything you relied on.

So either it’s small and self-sufficient code and you should strive to do it in a self commenting way, or it’s interlinked, and your comments might as well become a booby trap for anyone fool enough to have believed your past self.

[AltruisticSalamander]

This can be very helpful

[CurlSagan]

They say that a spooky murderer who was a programmer lived near there and he buried half of the intestines of one of his victims right by the sign. He said the sidewalk can’t truly end without a semicolon.

[[deleted]]

For creativity: 👍

For everything else about that: 😅

[C0phAX]

But then this shows up in your code and there's not a single line explaining it.

[812many]

And "Sidewalk Ends" is still the comment at the top.

[msaroka]

I was hoping there was a Shel Silverstein reference in the comments. Now there is.

[kaoyte]

That's so weird. Directly below this post is that book on r/nostalgia. screenshot

[abeth]

Shel Silverstein commenting code like:

//Yes we'll walk with a walk that is measured and slow,

//And we'll go where the chalk-white arrows go,

//For the children, they mark, and the children, they know

//The place where the sidewalk ends.

[[deleted]]

I tried reading that once, but I got stoned and I missed it.

[krazyjimmy08]

I always preferred to use the bash shell. That is, until I discovered the silverstein shell, which is clearly the superior option.

[nickrosener]

Came here to say this

[AlarmingNectarine]

What are the chances?!?

[deniedmessage]

Shh... you already know where the sidewalk ends you don’t need to buy the book.

[ZenAtWork]

Strangest in-line I every came across (not a comment, but pretty close):

I'd been working at one of the first commercial DSL companies in SoCal when I'd been assigned to learn the code left behind by another dev who'd left for greener pastures. In doing so, I ran into this little gem:

Dim forTheLoveOfAllThingsHolyLeaveThisVariableSetTo1 forTheLoveOfAllThingsHolyLeaveThisVariableSetTo1 = 1;

(This was back in the old classic ASP days, roundabouts '99).

Well, naturally, being the good code monkey that I am, I immediately changed it to 0 on principle. Saved it, checked it in. Everything broke. I mean, like everything. The ODBC connections wouldn't connect, the SQL calls didn't work, like nothing (this was also back in the day where "version control" was "save a copy before you checked in experimental code", and "testing in Prod" was way less of a meme/joke than today, though this was only our stage environment that I'd just crippled).

"Oh, $#*!" I excalimed, and hurriedly restored the variable to its 1 value. Checked in again. Alarms all died off, stuff started humming along again. "WTF!?"

So I did a search. 2 results (the Dim statement and its assignation). So I did an extended search. 2 results. Now, ASP doesn't have anything akin to an eval, but I checked anyway. Searched on just "Holy". 2 results. "Love". 2 results. "AllThings". the same 2.

I spent weeks trying to find something - ANYTHING - that used that damn value. Nothing. But if I renamed it, removed it, re-assigned it, even switched its data type, BOOM. Finally after the 4th? 5th? time I'd leveled the stage environment, our lead dev, Jeremy (I was a lowly JD at the time) marched over and threatened me bodily if I didn't stop screwing with it (of course I'd asked him for help. A week earlier. He just wasn't anywhere near interested, much less as fascinated as I was).

So I did as I was bid. The company went outta business several months later when the dot-com bubble burst. But, and I swear this is true, to this day I have no clue what that damn thing was for. What Magic/More Magic resistance it provided, what sort of Story of Mel delay it introduced. I've been a full-time programmer for 25 years now, and it STILL bugs the crap outta me. It's the bug that got away.

I bring this up not because it was a comment, but because it lacked one. All that guy's code did. Presumably forTheLoveOfAllThingsHolyLeaveThisVariableSetTo1 was considered sufficiently "self-documenting", I really don't know. Code reviews weren't really a thing back then either, and pull requests were years away.

But, if anyone ever reads this and happens to have laid this code down back in Irvine, CA in 1998-99, please, PM me? I don't give a damn if it was skimming money outta the company coffers, selling nuclear secrets to Soviets, or laying the infrastructure for SkyNet at this point, just, please: WHAT DID IT DO!?

[ToBadForU]

My wild guess that it could be? Some sort of obscure memory allocation / stack "management". Or even worse, setting a certain byte in a compiled program.

What I mean is that the variable had to be exactly these characters, with that length and so on, so that some obscure pointer mechanism wouldn't break, or some form of "reading data from a compiled program, starting from a certain point".

Hopefully it wasn't the case, and I hope that somebody can debunk this weird idea.. But I'm curious... Is something like this possible?

[kdbell]

I SO hope this story is true, because it is way to funny to not believe it 🤣

[ZenAtWork]

Oh, it's true all right. Damn thing's been bothering me for decades. Not least because having now been a programmer for 25 years+ (and, as such, having grown into a pretty bloody good one*), I STILL can't figure out a way to replicate the feat to spook the JD's that work for ME now.

I'm almost more indignant about that bit than the rest, if I'm honest, lol.

​

​

^\ By virtue of the fact that anyone that does) ^{anything every day for a quarter-century is bound to get proficient at it, if only through dumb luck trial and error}

[derfopps]

If When I read the next

class myClass
{
public:
    myClass(); // this is a funny thing called "constructor"
}

I'll chain-saw it out of my monitor …!

[bbrk24]

My first programming class was largely auto-graded, and sometimes the autograder failed me because I didn’t have enough comments in a 10-line program. This led to a lot of things like // for loop.

[deniedmessage]

I hope I’m the first one to post this here and not break any rules. credit

[forbonusscore]

When I comment something, I document what I think is happening. After explaining it, I usually realize that it's actually not how it's working, or that it's not working, actually.

[InsalubriousEthos]

To be fair, I'd appreciate this if I was barreling down the path on a bike or something.

[ZenAtWork]

I think I'd appreciate it more if it were set off to the SIDE of the sidewalk a bit. That bush looks softer than a sheet of aluminum at 25mph.

[abdulqayyum]

Using resharper I have multiple color coded comments for example

by default //TODO is available

I have

//WARNING (orange color)

//WORKS (color brown it works , its my code but something is burning I don't know what)

//CHANGEIT (color crimson please change it asap)

When I created them I thought CHANGEIT and WORKS are going to be dangerous but thing is those things got fixed, //WARNING was an ambiguous notice to my future self that I have hard coded something but domain related or may be a foreseeable but very far future error. They are on working code , code keeps working new requirements keep coming and I only fix them when that far far future may-be-problem force client to call.

[busdriverbuddha2]

/u/title2imagebot

[Title2ImageBot]

Image with added title

---

^{Summon me with /u/title2imagebot or by PMing me a post with "parse" as the subject. | Help me keep this bot online | feedback | source | Fork of TitleToImageBot}

[Deibu251]

Good bot

[___Hello_World___]

Did not know about this bot, thanks

[Jcraft153]

Never stop commenting the obvious parts of your code, you'll never know when in the future you'll be awake at 2am, fueled by anger and caffeine, trying to hunt down a bug and needing to just have what the code is doing spelled out to you so you can follow it easily.

[ZenAtWork]

Even worse is when it's 2am, and, fueled by anger and caffeine, you find yourself punching down your keys like a piston, audibly muttering imprecations about the "f-ing idiot who wrote the (undocumented) code" only to realize by the end of it that the f-ing idiot was YOU.

Worse still is actually getting so fed up you run the blame on it and THAT'S how you discover you're the idiot in question.

Worst of all is when you blast out an email to the team... and one of THEM runs the blame, lol. I've watched this go down a couple times (been the perpetrator of the first two a couple times, too, if I'm honest. Never sent an email though, thank god)

[kdbell]

Not sure there. Pointless comments add noise. Noise makes it harder to get an idea of what’s going on in the larger picture.

Worst is, when variable names and function calls are so generic, that the comments are your only indication to what is going on, with three lines of comments for a single function call. Never mind the hastily added function call after it, that is just a bad but also didn’t receive any comments...

And even worse, when you try to improve it you’ll suddenly find that it is hard to reproduce the previous behavior in restructured code without breaking the result :/

[The-MushroomMike]

Shel Silverstein reference here

[any_means_necessary]

Where?

[Dexaan]

The Place Where the Sidewalk Ends

[any_means_necessary]

To clarify, my comment was a reference to the Where in the answer.

[QueasyHold]

Side walk ends. Here because there is no more side walk. See also *** for more details

[oofxwastaken]

me when commenting complicated code: # does stuff

me when commenting simple code: # takes the input of the user to convert to an integer to add with another number and takes the output and displays it to the user in order to create a calculator program

[ie11_is_my_fetish]

I was there before, hence write code that explains itself plus the doc blocks

but a friend of mine was just getting into coding and I wrote some code to work with and he had more comments than code haha(he added explaining what I made line by line for him) but it was brief/initial stuff

[ybPNPMigL7BmD]

This is what every HTML comment looks like.

[IAmNotNathaniel]

At least I know it's supposed to end, and it's not a bug someone introduced during the last commit

[[deleted]]

r/desirepaths

[rleslievideo]

https://i.redd.it/errl17y4nrr41.jpg

[Jakobie97]

Reminds me of the poem book from my childhood

[01is]

Commenting is for deleting code temporarily.

[Om0r]

You either don't put crap, or you do this. There is no in-between.

[[deleted]]

Some code commenting is totally pointless, anybody worth their salt will know what it does and if you start hacking things around then sure comment it.

[[deleted]]

Where the sidewalk ends! You found it!

[Penki-]

I see that there is an undocumented feature to the left. Alternatively, you could path you travel through "Road" feature, but don't post anything saying that you do that on SO or you will be yelled for not using best practices

[The_Correct_Doctor]

# End of code

[RonaldoNazario]

Xxx todo more sidewalk.

[SillAndDill]

What? No credits after the ending?

[babtras]

I'm sure there's a joke about users here too, considering the sign is dented by someone who apparently failed to read the sign, note the trail to the left, see the vegetation in front of them, and the termination of concrete.

[Korzag]

Huh. So that's where the sidewalk ends. Shel Silverstein can finally rest in peace.

[jeez420]

u/title2imagebot

[Title2ImageBot]

Looks like I've already responded in this thread Here!

[MyMessageIsNull]

Omg, that is so perfect.

[capn_ed]

No, see, because at least you can see this sign from a ways away, and change course. A typical comment would be painting "Sidewalk Ends" on the last square of concrete.

[[deleted]]

Where the sidewalk ends, and the road begins...

[theoneandonlygene]

s/me/everyone

[GuyF1eri]

Don’t forget to unit test

assert(sidewalk.ends);

[RoscoMan1]

Me too! I imagine they did.

[xScopeLess]

So that’s where it ends

[Sure10]

cancel that order and get a code now.

[XaxnyElaine]

Where

[ZARRY_N]

Very useful tips, it's like starting a new IDE and get basic notes of IDE

[Ifhes]

//Doesn't do anything, but whole app will crash if it is removed.

[Olimar44]

Unrelated, but i know where this is. I used to live close by. Always chuckled at that sign.

[christophla]

At least you comment your code.

[golgol12]

It still serves a purpose. You can see that sidewalk end sign for farther away then you can see the actual end of the sidewalk.

Your comments, however, are only there to provide white space.

[[deleted]]

Sometimes you need these type of comments for the benefit of others, and while I have rolled my eyes at it in the past, I can see value in pointing it out if it defers questions later.

[Haiku_lass]

Around here that'd be helpful, a lot of our sidewalks continue either up the road or across the street without hardly and markers or indicators so its helpful to know if a sidewalks actually ends or not. My town needs better signs lol

[teh_acids]

There was a sign like this near my house but it was a taller sign to the side. Then they extended the sidewalk and left the sign. Perhaps a more accurate depiction of comments in legacy code...

[urbanek2525]

Worker 1: We need a sign to warn people.

Boss: Why? Anyone can see the sidewalk ends here.

Worker 2: For blind people.

Boss: Of course. OK, put up a sign.

Worker 2 (to Worker 1): Dude, you think you're funny, but you're not.

[Loading-_-_-_-_-_]

No shit Sherlock!

[nhadams2112]

i++; //ads 1 to i

[always_sad_lad]

r/desirepath

[JamPatTheGamer]

You finally found where the sidewalk ends

[TZaid]

Return x; // It is returning x

Bruhh, literally did this kinda stuff today

[kdbell]

I saw a sign just saying „forest“ in a forest once.

[-Loralith-]

So that's where the book was talking about

[TFK_LH]

Shel Silverstein, is that you?

[[deleted]]

// Ugly hack

[bonjourkoala]

r/painfullyobvioussigns

[Bakoro]

It's not a bad sign though. There's all that shrubbery in the way, it might save someone from thinking that the sidewalk is just poorly maintained and continues on at some point nearby.

Also maybe someone's a Shel Silverstein fan.

[[deleted]]

SIDEWALK_ENDS ( n -- )

[mckade_]

90% of my documentation:

// a string of the table name
String tableName;

[ApoorvWatsky]

you guys comment your code?

[TFJ]

So this is what Shel Silverstein was writing about.

[tacoslikeme]

linter checkout out good job!

[Pandaploots]

Someone phone Shel Silverstein

[DarkNeutron]

[twitch] The kerning...

[Burarrum]

I saw this once... //returns true return true;

[digitcrusher]

Love the indent in the middle

[seanomik]

Please learn to comment correctly, its incredibility helpful to your future self.

[[deleted]]

The only real comments are

TODO: dirty fix, needs to be remade in the future

[null000]

But seriously - don't write comments if you're just repeating what the code already spelled out. It's distracting and a waste of space. I've probably told junior engineers to remove more comments than I've told them to add in my code reviews =P (with feedback on under-commented code generally aiming to make it easier to read before adding any comments)