this post was submitted on 31 Jul 2023
48 points (96.2% liked)
Programming
17354 readers
303 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
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 [email protected]
founded 1 year ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
Yes, serious people write docs. I hate this bullshit about code that should be so good that it's "auto-documenting." It never happens in real life. Code is at best of average quality, but it needs documentation. At my previous job they had "guidelines" to make sure that code didn't needed doc. It was a bad joke and we had the worst code I've ever seen.
I don't have solutions for you though. You need a combo of documentation generation, code formatter (in the CI maybe, or before a commit), and code linters to check for errors.
Writing self documenting code reduces the need for comments significantly, but you'll still need to write docs and even code comments when needed.
I had a lead architect at one of my previous workplaces who outright forbid writing comments, otherwise the build would fail. That lead to convoluted and slow solutions in order to make the code readable, or just parts that nobody wanted to touch because nobody understood them.
My point is that you should strive towards self documenting code as much as it makes sense, but don't take it to mean that you should never write comments.
People should be able to tell what your code does without going deep into implementation details but that's not always possible, especially if you're working with lower level languages with fewer abstractions, or projects with complex algorithms or architecture.
Its wild to me that some people hear "your code should be self documenting" and take that to mean "never write comments".
All self documenting should mean is I can look at a method and get a general understanding of what it does, and it shouldn't have any unknown functionality. Specific implementations, design quirks, choices that might only make sense if you know business context should all be comments in your code.
On the other side of all that I worked with someone who insisted methods were documented college style, the "authors" name, date it was written, what it does, why it's here, our star sign. I hate that just as much, so much clutter.
It's the same people that hear "security by obscurity is not security" and take it to mean "publicity is more secure than obscurity". A key being under a door mat is bad but putting it on top of the mat because "obscurity isn't security" is silly.
Edit: A better example is having a hidden door with a look is still more secure than having a non-hidden door with a lock.
“Self-documenting” just means “(I thought) I understood it when I wrote it, so you should too”. In other words, it really means “I don’t want to document my code”
I like it better when the docs are embedded in the code or alongside them. Everywhere I've worked it is a pain trying to find some random Confluence page or whatever where some API doc is.
Also if it's not in the code, it will get outdated quickly and nobody will ever look at it. Separate docs are only really useful for main concepts that are not going to change that quickly.