Tagged articles
code comments
37 articles · Page 1 of 1
This article explores the nightmare of inheriting uncommented, poorly structured code from departed developers, illustrating anti-patterns like cryptic naming, deep nesting, magic numbers, and copy-paste duplication, while providing a four-step refactoring guide and team-level prevention strategies including code reviews, coding standards, and offboarding practices.
code commentscode qualitycode review
0 likes · 25 min read

The author argues that well‑written, regularly maintained code comments explain design decisions, make future modifications safer, and therefore serve as an effective tool for lowering technical debt, despite common claims that clean code alone eliminates the need for comments.
Best Practicescode commentsdocumentation
0 likes · 4 min read

The author argues that in clear business code, comments should cover both the overall process (what) and the rationale behind decisions (why), using concise flow annotations and explanatory notes to reduce reading cost while avoiding excessive commentary on already‑self‑explanatory code.
Best Practicescode commentsdocumentation
0 likes · 5 min read

This guide shows how to configure IntelliJ IDEA to automatically generate class and method Javadoc comments using File and Code Templates for classes and Live Templates for methods, including custom Groovy scripts for @param and @return annotations.
IDE automationIntelliJ IDEAJava
0 likes · 7 min read


ITPUBJun 29, 2025 · Fundamentals
The article examines the criminal and civil legal boundaries of deleting code comments in the IT industry, outlines the criteria for severe consequences, analyzes the technical difficulty and cost of such actions, and shares expert and community perspectives on why this practice is largely harmless yet potentially liable.
LegalSoftwarecivil liability
0 likes · 6 min read

This guide outlines practical C coding standards covering clear and concise code, consistent naming conventions for variables, functions, constants, enums, macros, and files, proper header protection, include ordering, inline function usage, and effective commenting to improve readability and maintainability.
c-programmingcode commentscoding standards
0 likes · 13 min read

This article explains the importance of good comments and docstrings in Python, describes the basic syntax for single‑line, multi‑line, and docstring comments, and provides ten practical examples illustrating various annotation techniques and their typical use cases.
Pythoncode commentsdocstring
0 likes · 9 min read

The article explains why comprehensive code comments are essential, outlines nine distinct comment types advocated by Redis creator antirez, and shows how each improves readability, maintenance, and collaboration in software projects.
Best Practicescode commentscoding standards
0 likes · 7 min read

Effective code comments fall into nine categories—six recommended types such as function, design, why, teacher, checklist, and guide comments, and three to avoid (trivial, debt, backup)—and using the right kind improves readability, maintenance, and AI‑assisted understanding of software projects.
code commentscoding standardsdocumentation
0 likes · 7 min read

This article presents four actionable techniques—clearly stating requirements, requesting code comments, invoking the Composer with Command/Ctrl + I, and configuring AI rules in Settings—to help developers maximize productivity when working with the Cursor AI coding assistant.
AI codingCursorProductivity
0 likes · 4 min read

This guide explains practical methods—including specialized tools, custom scripts, and regular‑expression tricks in editors like VS Code and Notepad++—to efficiently strip //, /* */ and blank‑line comments from C/C++ source files for software copyright submissions.
Notepad++Python scriptVS Code
0 likes · 4 min read

This article introduces the Chinese copywriting guidelines, explaining why spaces between Chinese and English, numbers, units, and punctuation matter, providing concrete examples and best‑practice rules, and showcasing the autocorrect CLI tool and language libraries that can automatically enforce these formatting standards.
CLI toolChinese copywritingFormatting
0 likes · 16 min read

This guide explains the value of code comments in embedded development, warns against excessive or insufficient annotation, and provides concrete best‑practice rules, principles, and code examples to help engineers write clear, maintainable documentation within their source files.
code commentsdocumentationsoftware engineering
0 likes · 11 min read

Effective Java commenting follows a clear hierarchy—using single‑line, block, and Javadoc styles—while aligning comments with code, inserting blank lines, and limiting redundancy, so that each comment explains intent, summarizes complex sections, documents parameters, and aids maintainability without overwhelming the source.
Best PracticesJavacode comments
0 likes · 15 min read

This article explores why programmers dislike both reading uncommented code and writing comments, outlines the drawbacks of excessive annotations, categorizes common bad comment patterns, and offers practical techniques—such as self‑descriptive naming, refactoring, and using built‑in validation methods—to produce clear, maintainable code without relying on comments.
Clean Codecode commentsrefactoring
0 likes · 7 min read


21CTODec 1, 2022 · Frontend Development
This article outlines eight practical JavaScript habits—using let/const, writing meaningful comments, preferring == over ===, leveraging optional chaining, avoiding magic values, handling async errors, passing multiple parameters instead of a single object, and using concise conditionals—to produce more maintainable, readable, and robust code.
Clean CodeJavaScriptOptional Chaining
0 likes · 7 min read

The article argues that code comments are essential, explaining why ignoring them leads to unreadable, error‑prone software, and demonstrates that even brief annotations can save hours of debugging, especially after months of neglect or when others inherit the code.
Best Practicescode commentsdocumentation
0 likes · 11 min read


21CTOSep 1, 2022 · Fundamentals
This article explores the cultural, historical, and practical reasons behind developers' quirky code comments, presents amusing examples from various languages, shares statistics on comment density, and reflects on how these annotations affect teamwork, code readability, and developer morale.
Best Practicescode commentshumor
0 likes · 15 min read

The article explores the purpose, controversy, and best practices of code comments, arguing that while excellent code can be self‑explanatory, thoughtful comments are essential for readability, maintenance, and conveying intent, especially in complex or ambiguous scenarios.
Best PracticesClean CodeJava
0 likes · 21 min read

This article examines the purpose and controversy of code comments, arguing that while well‑written code should be self‑explanatory, strategic comments can bridge gaps in readability, aid maintenance, and convey intent, especially in complex or legacy codebases.
Best PracticesClean Codecode comments
0 likes · 19 min read

This article examines the ongoing debate over code comments, explains when comments add value or cause noise, and outlines three practical guidelines—commenting only complex business logic, avoiding log‑type and positional markers—to improve JavaScript code readability.
Best PracticesClean CodeJavaScript
0 likes · 7 min read


ITPUBMar 24, 2021 · Fundamentals
The article emphasizes that clear, well‑structured comments are vital for code readability, team collaboration, maintenance, and knowledge transfer, illustrating common pitfalls through developer anecdotes and offering practical guidelines such as writing concise explanations, categorizing notes, timing comments, and preserving code history to avoid future confusion.
Collaborationcode commentsmaintainability
0 likes · 10 min read

This article explains the importance of comments in C/C++ code and provides detailed guidelines for file, function, variable, spelling, and TODO annotations, including examples and best‑practice recommendations to improve code readability and maintainability.
C++code commentssoftware engineering
0 likes · 6 min read

This guide explains why comments are essential for code readability, outlines various comment styles for C/C++—including file, function, variable, spelling, and TODO comments—and provides concrete examples and best‑practice recommendations to help developers write clear, maintainable code.
Best PracticesC++code comments
0 likes · 6 min read

A recent discovery reveals that Apple’s open‑source file make_tapi_happy.h includes a humorous "only god knows why" comment about WeChat compatibility, highlighting how business negotiations can leave quirky traces in source code.
AppleWeChatcode comments
0 likes · 4 min read

This article explains why comments are essential for code readability, outlines consistent comment styles, details file, function, variable, spelling, and TODO annotations, and provides practical examples to help developers write clear, maintainable C/C++ documentation.
C++code commentscoding standards
0 likes · 7 min read

The article examines common problematic comment styles—such as embedding contact info, design details, "how" instead of "why", usage instructions, and algorithm explanations—and suggests modern Git‑based practices to keep code clean and maintainable.
Best PracticesGitcode comments
0 likes · 4 min read


政采云技术Sep 27, 2020 · Frontend Development
This article explains why comments are essential for code readability and maintenance, describes the syntax of comments in HTML, CSS, JavaScript and other languages, shows practical shortcuts, special tags, real‑world examples, and recommends VS Code extensions for writing consistent, useful annotations.
CSSHTMLVS Code extensions
0 likes · 16 min read


21CTOSep 22, 2019 · Fundamentals
This article distills the core principles from John Ousterhout's *A Philosophy of Software Design*—defining software complexity, presenting a quantitative model, and offering practical strategies such as layering, modularization, information hiding, and effective commenting—to help engineers build maintainable, low‑complexity systems.
code commentscomplexity reductionmodular architecture
0 likes · 20 min read

The article advises front‑end developers to improve JavaScript function quality by adopting clear, English‑style names, using consistent prefixes for visibility, writing informative comments such as JSDoc, and applying defensive programming techniques—including default parameters, try/catch, and granular promise error handling—to create maintainable, robust code.
Robustnesscode commentsfrontend
0 likes · 17 min read


21CTOApr 10, 2017 · Fundamentals
This article examines the role of comments in source code, argues that well‑written, transparent code can often eliminate the need for comments, outlines four levels of code quality, provides concrete refactoring examples, and shares practical clean‑code guidelines such as avoiding magic numbers, reducing parameters, and using contract‑style preconditions.
Best PracticesClean Codecode comments
0 likes · 9 min read

This discussion post examines whether code should be commented, citing the book *Refactoring* and emphasizing that needing comments often signals the need for refactoring, while good variable names can serve as implicit documentation, and stresses the importance of clear interface comments.
Best Practicescode commentscoding standards
0 likes · 2 min read

The article argues that comments often degrade code readability, identifies two common comment‑related problems—poor naming and overly long methods—and proposes a zero‑comment approach that relies on accurate naming, short methods, and self‑describing code, illustrated with C# examples.
Clean Codecode commentscoding standards
0 likes · 7 min read

Through a collection of humorous and often pointless code comment examples, the article examines how developers use annotations—ranging from cryptic references to overly detailed narratives—to convey (or obscure) intent, highlighting best practices and pitfalls in writing effective code comments.
Best Practicescode commentshumor
0 likes · 8 min read


21CTOAug 24, 2015 · Fundamentals
This article explains five common types of programming comments that hinder readability—such as self‑promoting tags, outdated code blocks, redundant explanations, irrelevant stories, and lingering TODOs—and offers practical advice on how to avoid them.
Best PracticesCode Readabilitycode comments
0 likes · 7 min read

This article compiles ten provocative programming viewpoints—from the primacy of using your brain over rigid best‑practice checklists to the limits of unit testing—offering practical reflections on mindset, learning, tooling, and design that can sharpen any developer’s approach.
Best Practicescode commentsdeveloper mindset
0 likes · 6 min read

The article showcases the top ten most memorable and humorous code comments harvested from a StackOverflow discussion, ranging from sarcastic warnings and epic motivational messages to absurd exception handling and playful macros, illustrating how developers inject personality into code while inviting readers to share even funnier examples.
Best PracticesStackOverflowcode comments
0 likes · 3 min read
