I recently hired into a data analytics team for a hospital, and we don’t have a style guide. Lots of frustration from folks working with legacy code…I thought putting together a style guide would help folks working with code they didn’t write, starting with requiring a header for SQL scripts first as low hanging fruit.
Or so I thought.
My counterpart over application development says that we shouldnt be documenting any metadata in-line, and he’d rather implement “docfx” if we want to improve code metadata and documentation. I’m terrified of half-implementing yet another application to further muddy the waters–i’m concerned it will become just one-more place to look while troubleshooting something.
Am I going crazy? I thought code headers were an industry standard, and in-line comments are regarded as practically necessary when working with a larger team…
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.