Tagged articles
Code Maintainability
36 articles · Page 1 of 1
This article identifies five common MapStruct misuses — complex logic in @Mapping expressions, missing bidirectional relationship handling, over-mapping in hot paths, injecting business services into mappers, and naive PATCH updates — and shows correct Java alternatives for each case.
Code MaintainabilityJPAJava
0 likes · 11 min read


21CTOJul 20, 2026 · R&D Management
A team that relied entirely on AI tools like Codex to rush a multi‑channel customer‑service chatbot into production ended up with unreadable code, endless bug‑fix loops, performance crashes, and a loss of engineering control, illustrating the hidden risks of AI‑only development.
AI codingAI-assisted developmentCode Maintainability
0 likes · 5 min read

The article explains how functional programming’s emphasis on immutability and composability can dramatically reduce bugs, simplify testing, and improve maintainability, illustrated by a real‑world automotive sensor module that saw a 30% code‑size cut, an 80% bug drop, and test coverage rise from 40% to 90%.
Code Maintainabilitycomposabilityfunctional programming
0 likes · 5 min read

The article argues that after age 35 developers should focus on core skills such as problem modeling, system observability, and code evolvability because technology churn outpaces personal learning, AI handles tool usage, and companies value stability over novelty.
Code Maintainabilitycareer adviceobservability
0 likes · 3 min read

The author recounts how maintaining and evolving a long‑lived production system exposed hidden costs of poor low‑level design, leading to a shift from pattern‑first thinking to change‑driven analysis, small incremental refactorings, and ultimately a calmer, more maintainable codebase.
Code Maintainabilitydesign patternslow-level design
0 likes · 16 min read

The article explains how excessive, fake, or chaotic encapsulation creates hidden risks, reduces maintainability, and hampers extensibility, then provides concrete refactoring examples and practical principles to achieve clean, purposeful encapsulation in backend code.
Best PracticesCode MaintainabilityEncapsulation
0 likes · 11 min read

This article explains what PHP static methods are, shows how to declare them, and examines their advantages such as no instantiation and increased reusability, as well as their disadvantages including testing difficulty and maintainability concerns.
Code Maintainabilityobject-oriented programmingstatic methods
0 likes · 4 min read

The article explains why traditional switch statements violate the Open/Closed principle in JavaScript, outlines the maintenance problems they cause in large front‑end codebases, and demonstrates how object literals or Map structures provide cleaner, more extensible alternatives.
Code MaintainabilityOpen/Closed Principlemap
0 likes · 5 min read

The article explains how using a state‑machine approach in embedded C programs can eliminate wasteful delay loops, ensure logical completeness, and produce clearer, more maintainable code by structuring work around events and states.
CPU efficiencyCode Maintainabilityembedded C
0 likes · 5 min read

This article explains the Facade design pattern, illustrating its purpose of simplifying complex systems with real‑world analogies, detailing its benefits, showing UML class diagram relationships, and providing a comprehensive Spring Boot example that encapsulates flight, hotel, and package services behind a BookingFacade, while also including promotional content for IDE licenses.
Code MaintainabilityFacade PatternSpring Boot
0 likes · 15 min read


大转转FEDec 27, 2024 · Frontend Development
This article explores the concept of code maintainability, explains why it matters, defines key measurement metrics such as naming conventions, comment density, code volume, logical lines, cyclomatic complexity, similarity and redundancy, and provides practical improvement techniques and tool recommendations for modern front‑end projects.
Best PracticesCode Maintainabilitycode quality
0 likes · 50 min read

The article explains how deeply nested if‑else statements create spaghetti code and proposes three refactoring techniques—function extraction, lookup‑table mapping, and the responsibility‑chain pattern—to replace complex conditional trees with modular, readable structures that dramatically lower control‑flow complexity.
Code MaintainabilityJavaScriptif-else
0 likes · 9 min read


21CTOJun 2, 2024 · Fundamentals
The article shares hard‑earned lessons from a veteran software engineer about treating coding as a craft, avoiding the "Not‑Invented‑Here" syndrome, managing complexity, writing tests, and documenting well to reduce future maintenance pain and improve code quality.
Best PracticesCode MaintainabilityNIH syndrome
0 likes · 10 min read

When extending existing code, developers must decide between adding parameter‑based conditional logic or introducing a new function, weighing benefits such as code centralization against drawbacks like increased complexity, readability, and maintainability, while considering single‑responsibility, reuse, default parameters, overloads, and design patterns.
Code Maintainabilityfunction designparameter handling
0 likes · 4 min read

Static methods in PHP allow functions to be called directly via the class without instantiation, offering benefits such as simplicity, resource savings, and reusability, but they also introduce drawbacks like testing difficulty, reduced maintainability, and limited extensibility, requiring careful consideration before use.
Code MaintainabilityPHPbackend development
0 likes · 4 min read

This article explains the Facade design pattern, its benefits such as simplifying complexity, encapsulating subsystems, and improving maintainability, and demonstrates its practical use in PHP by building an online shopping cart with clear code examples and a step‑by‑step implementation.
Code MaintainabilityFacadedesign-patterns
0 likes · 5 min read


21CTOSep 18, 2023 · Fundamentals
This article explains what clean code is, why it matters for readability, collaboration and efficiency, and presents ten practical guidelines—including meaningful naming, concise functions, proper comments, consistent formatting, DRY, spacing, error handling, testing, refactoring, and version control—complete with JavaScript examples.
Best PracticesClean CodeCode Maintainability
0 likes · 13 min read

The article discusses how clear naming, structured organization, thorough documentation, robust testing, effective logging, observability, and modular design together enhance code readability, testability, and extensibility, ultimately leading to more maintainable software projects.
Code MaintainabilityExtensibilityreadability
0 likes · 7 min read

This tongue‑in‑cheek article lists a series of deliberately harmful coding techniques—from confusing variable names and deceptive documentation to over‑engineered designs and absent testing—illustrating how to make software virtually impossible to maintain.
Code MaintainabilityJavabad coding practices
0 likes · 14 min read

Design patterns, often hailed as software design standards, can lead to over‑engineering, increased complexity, and maintenance challenges in fast‑changing internet applications, but when applied judiciously and evolved with functional approaches, they also enhance code reuse, readability, and long‑term system growth.
Code Maintainabilitydesign patternsfunctional programming
0 likes · 22 min read

This article compiles essential programming principles such as KISS, DRY, YAGNI, and others, explaining their origins, practical advice, and additional design guidelines to help developers write simpler, more maintainable, and less error‑prone code.
Code MaintainabilityDRYKISS
0 likes · 10 min read

This article explains essential software design principles such as KISS, DRY, YAGNI, and additional guidelines for writing maintainable, simple code, while also warning against over‑engineering and emphasizing the importance of testing, clear communication, and minimal coupling in everyday programming practice.
Code MaintainabilityDRYKISS
0 likes · 11 min read

This article outlines essential programming principles—including KISS, DRY, YAGNI, and Code for the Maintainer—explaining their origins, practical applications, and how they help developers write simpler, more maintainable, and less error‑prone software.
Clean CodeCode MaintainabilityDRY
0 likes · 11 min read

This article compiles essential programming principles such as KISS, DRY, YAGNI, and Code for the Maintainer, explains their origins, practical applications, and concrete guidelines to help developers write simple, maintainable, and efficient code while avoiding unnecessary complexity.
Code MaintainabilityDRYKISS
0 likes · 12 min read

This article explores why CSS often becomes messy, introduces aesthetic considerations, outlines three core writing principles—less is more, self‑explanatory, reusable—and provides concrete techniques such as naming conventions, formatting, commenting, modularization, and tooling to keep styles clean, readable, and maintainable across teams.
Best PracticesCSSCode Maintainability
0 likes · 17 min read

The article explains that while a Service layer may seem unnecessary for simple business logic, it becomes essential as applications grow, offering benefits such as handling complex operations, supporting reuse across controllers, facilitating unit testing, and enabling flexible business logic composition.
Code MaintainabilityService Layerbackend architecture
0 likes · 3 min read


政采云技术Dec 1, 2020 · Frontend Development
This article explains how to write high-quality, maintainable frontend code by exploring component abstraction, granularity, design principles, and classification—from atomic to page-level components—illustrated with React and Vue examples, code snippets, and practical guidelines for balancing reuse and complexity.
Code MaintainabilityVueabstraction
0 likes · 15 min read

Excessive if‑else statements can make code hard to maintain, but by distinguishing exception handling from state handling and applying techniques such as condition merging, early exits, removing temporary variables, and leveraging polymorphism, developers can refactor code to be clearer, shorter, and more robust.
Code MaintainabilityPolymorphismif-else
0 likes · 12 min read

After a year of using Project Lombok, the author reflects on how the library initially reduces boilerplate but ultimately introduces version incompatibilities, forced dependencies, reduced readability, tighter coupling, and technical debt, urging developers to weigh its benefits against long‑term maintenance risks.
AnnotationsBoilerplateCode Maintainability
0 likes · 10 min read

This article examines TypeScript—a Microsoft‑backed JavaScript superset—detailing its static‑typing benefits, improved readability, bug reduction, and active ecosystem while also discussing learning costs, slower development speed, library compatibility issues, and the necessity of compilation, helping developers decide whether to adopt it.
Code MaintainabilityFrontend DevelopmentJavaScript
0 likes · 11 min read

The article explains why unit tests should focus on verifying distinct behaviors rather than mirroring methods, advocating separate, focused tests that make cause‑and‑effect relationships obvious and improve code readability and maintainability.
Code Maintainabilitybehavioral testingsoftware testing
0 likes · 4 min read

The article argues that, despite the popularity of design patterns, blindly applying the 23 classic patterns rarely improves software quality and often leads to over‑engineered or fragile code, urging developers to critically assess their context, language features, and multi‑paradigm alternatives before using them.
Code Maintainabilitydesign patternsobject-oriented programming
0 likes · 16 min read

This article walks through three progressive refactoring stages for Vuex‑based API calls—first separating concerns for maintainable code, then introducing a concise “olive‑shaped” interface with dynamic generation or proxy interception, and finally adding response normalization and three‑level error handling to produce robust, low‑maintenance frontend logic.
API RefactoringCode MaintainabilityFrontend Architecture
0 likes · 14 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

The article discusses how type mismatches cause runtime errors in JavaScript projects, explains why static typing with TypeScript can catch these issues at compile time, and argues that rigorous type declarations are essential for building and maintaining large‑scale frontend applications.
Code MaintainabilityJavaScriptTypeScript
0 likes · 6 min read

The article argues that treating lines of code as a cost rather than a product encourages writing disposable, loosely‑coupled software, and it walks through practical stages—from avoiding code entirely to using feature flags—to build systems that are easier to modify, replace, or discard.
Code MaintainabilityLoose Couplingdisposable code
0 likes · 20 min read
