Tagged articles
bad practices
20 articles · Page 1 of 1
The article lists twelve concrete anti‑patterns—such as over‑splitting microservices, writing megamethods, deep nesting, misleading comments, copy‑pasting code, ignoring logging, and over‑engineering with heavyweight frameworks—that dramatically reduce code readability and make maintenance a nightmare, illustrated through the fictional programmer Er Gou and his bewildered teammates.
bad practicescode qualitylogging
0 likes · 13 min read

The article humorously outlines twelve detrimental coding habits—from over‑splitting microservices to avoiding logs—that cripple readability and maintainability, illustrating each with a fictional programmer “Er Gou” and warning developers not to follow these anti‑patterns.
bad practicesloggingmicroservices
0 likes · 12 min read

This article lists nine common TypeScript pitfalls—such as disabling strict mode, misusing the || operator, overusing any, and vague generic names—and explains the correct practices and reasons to adopt them, helping developers write more maintainable and type‑safe code.
TypeScriptbad practices
0 likes · 5 min read

The article humorously lists twelve detrimental coding habits—such as over‑splitting microservices, writing excessively long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and reinventing wheels—that reduce code readability and increase maintenance difficulty.
bad practicescode qualityframework misuse
0 likes · 11 min read

The article lists twelve common anti‑patterns—such as splitting microservices per table, writing overly long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and over‑engineering solutions—that dramatically reduce code readability and make maintenance a nightmare.
Code Readabilitybad practicesmicroservices
0 likes · 11 min read


ITPUBDec 2, 2023 · Fundamentals
The article lists twelve common anti‑patterns—such as over‑splitting microservices, writing excessively long methods, random naming, misleading comments, and avoiding logging—that dramatically reduce code readability and increase maintenance difficulty, illustrating each with a fictional developer’s missteps.
bad practicescode qualitymicroservices
0 likes · 11 min read

This tongue‑in‑cheek article lists a series of deliberately bad coding practices—ranging from confusing naming conventions and deceptive comments to abusive design choices and omitted testing—intended to illustrate how developers can make their software virtually impossible to maintain.
Javabad practicescode anti-patterns
0 likes · 14 min read

This satirical guide enumerates absurd techniques—from confusing naming conventions and deceptive comments to overloaded functions and excessive nesting—that deliberately make code hard to read, test, and maintain, offering a tongue‑in‑cheek look at worst‑case software engineering practices.
bad practicescode anti-patternsmaintainability
0 likes · 14 min read

This tongue‑in‑cheek guide enumerates a series of deliberately bad programming techniques—ranging from confusing naming conventions and deceptive comments to absurd design choices and hidden macros—aimed at making code virtually impossible to understand, maintain, or test.
bad practicescode obfuscationmaintainability
0 likes · 17 min read

This tongue‑in‑cheek guide enumerates a series of anti‑patterns—from confusing naming and deceptive comments to absurd design choices and neglect of testing—intended to illustrate how developers can deliberately produce code that is extremely hard to maintain.
Javabad practicescode anti-patterns
0 likes · 13 min read


ITPUBSep 2, 2021 · Fundamentals
This tongue‑in‑cheek article enumerates a series of deliberately bad programming practices—from confusing naming conventions and deceptive comments to abusive design choices and anti‑testing habits—showing how to make code virtually impossible for colleagues to understand or maintain.
bad practicescode anti-patternsmaintainability
0 likes · 14 min read

The article lists twenty‑one harmful programming habits—such as reinventing wheels, overusing design patterns, skipping testing, ignoring monitoring, and avoiding proper architecture—that can cripple a development team and serve as a warning for engineers seeking better practices.
DevOpsanti-patternsbad practices
0 likes · 6 min read

A satirical list of ten misguided developer habits—from obsessively mastering JavaScript to ignoring communication—highlights how these anti‑patterns sabotage code quality, teamwork, and career growth, offering a cautionary guide for anyone aiming to become a better programmer.
JavaScriptbad practicescoding anti-patterns
0 likes · 9 min read

This tongue‑in‑cheek article enumerates a series of deliberately bad programming practices—from confusing variable names and misleading comments to over‑engineered designs and zero testing—to show how to make code virtually impossible to maintain.
Javabad practicescode quality
0 likes · 12 min read

This article humorously presents a GitHub project's 19 tongue‑in‑cheek guidelines for writing terrible code—from typing less and mixing naming styles to avoiding comments, tests, and documentation—while illustrating each rule with vivid examples and images.
bad practicescode qualitycoding guidelines
0 likes · 8 min read


ITPUBFeb 19, 2020 · Fundamentals
This tongue‑in‑cheek article enumerates a series of deliberately bad programming techniques—from confusing variable names and deceptive comments to over‑engineered designs and anti‑testing habits—showing how to make code virtually impossible to understand or maintain.
Code Maintainabilitybad practicesprogramming
0 likes · 14 min read

This tongue‑in‑cheek article enumerates a series of deliberately harmful programming anti‑patterns—from confusing variable names and deceptive documentation to absurd design choices and nonexistent testing—showing how to make code virtually impossible to understand or maintain.
bad practicescode anti-patternsobfuscation
0 likes · 14 min read

An eye‑opening roundup of seven notoriously awful Java snippets—from misused StringBuffer and endless nested loops to convoluted Stream pipelines and absurd exception definitions—showcasing why such code is a nightmare, how it hampers readability, and what refactoring strategies can rescue it.
JavaStream APIbad practices
0 likes · 15 min read

The article humorously explores nine commonly discouraged programming habits—such as using goto, avoiding documentation, cramming code onto one line, omitting type declarations, and redefining operators—explaining why developers sometimes break rules and how these practices can affect code readability, maintainability, and performance.
bad practicescode qualitycoding style
0 likes · 14 min read


21CTONov 30, 2015 · Fundamentals
While many developers know they should avoid certain coding shortcuts, this article reveals nine surprisingly common bad programming habits—like using goto, skipping documentation, over‑compressing code, and redefining operators—that programmers often cling to, explaining their origins, risks, and occasional hidden benefits.
Gotobad practicescode quality
0 likes · 14 min read
