BestHub
Sign in
Tagged articles

clean code

151 articles · Page 1 of 2
samdeepthink
samdeepthink
Jul 30, 2026 · Backend Development

Live Refactor: Turning a Messy Java Registration Method into Intent‑Clear Code

The article demonstrates how a convoluted Java user‑registration method—filled with magic error codes, inline regex checks, deep nesting, and mutable parameters—can be systematically refactored by introducing meaningful exception types, extracting password validation, applying early‑return style, and using immutable request records to produce clear, intent‑driven code.

Code RefactoringException HandlingImmutability
0 likes · 7 min read
Live Refactor: Turning a Messy Java Registration Method into Intent‑Clear Code
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 27, 2026 · Backend Development

Stop Building Code “Shit Mountains” – 10 Java Clean‑Code Techniques

This article presents ten practical Java clean‑code techniques—from meaningful naming and single‑purpose methods to avoiding magic numbers, writing purposeful comments, proper logging, defensive programming, DTO separation, Stream API usage, Optional handling, and safe ThreadPoolExecutor configuration—each illustrated with concrete code examples and explanations.

DTOOptionalStream API
0 likes · 12 min read
Stop Building Code “Shit Mountains” – 10 Java Clean‑Code Techniques
samdeepthink
samdeepthink
Jun 18, 2026 · Fundamentals

Why Code Cleanliness Is a Professional Habit, Not Just a Quirk

The article argues that code cleanliness—careful naming, clear responsibilities, consistent abstraction levels, and purposeful design patterns—boosts maintainability and delivery efficiency, while warning against over‑formatting, premature abstraction, and needless refactoring of legacy code.

Software DesignStrategy Patternclean code
0 likes · 10 min read
Why Code Cleanliness Is a Professional Habit, Not Just a Quirk
Yunqi AI+
Yunqi AI+
Apr 11, 2026 · Fundamentals

Two Principles to Make AI‑Generated Code Easy to Maintain

The article explains how the Composed Method Pattern (CMP) and the Single Level of Abstraction Principle (SLAP) can keep AI‑generated code readable, maintainable, and team‑friendly by structuring entry methods as narratives and ensuring each method stays at a single abstraction level.

AI code generationCMPSLAP
0 likes · 16 min read
Two Principles to Make AI‑Generated Code Easy to Maintain
Java Web Project
Java Web Project
Jan 14, 2026 · Backend Development

How to Turn Bloated Spring Controllers into Clean, Maintainable Code

The article analyzes why Spring MVC controllers often become massive with repetitive validation, logging, and business logic, demonstrates an ugly controller example, then shows step‑by‑step refactoring using @Valid, assertion utilities, and a global exception handler to dramatically reduce code size and improve readability.

@ValidController RefactoringException Handling
0 likes · 8 min read
How to Turn Bloated Spring Controllers into Clean, Maintainable Code
macrozheng
macrozheng
Jan 4, 2026 · Fundamentals

Master KISS, DRY, and SOLID: Practical Tips and Real‑World Code Examples

This article explains the core software design principles KISS, DRY, and SOLID, shows why they matter for readability and maintainability, provides concrete Java examples and step‑by‑step guidelines, and lists actionable rules developers can follow to write cleaner, more reusable code.

DRYKISSSOLID
0 likes · 19 min read
Master KISS, DRY, and SOLID: Practical Tips and Real‑World Code Examples
Architect's Tech Stack
Architect's Tech Stack
Oct 11, 2025 · Fundamentals

Why Clean Code Matters: Master Naming, Classes, Functions & Testing

This article explains why clean code is crucial for projects and developers, covering the importance of readable naming, single‑responsibility classes, well‑structured functions, and effective testing practices to boost productivity and reduce technical debt.

Software Designclean codenaming conventions
0 likes · 15 min read
Why Clean Code Matters: Master Naming, Classes, Functions & Testing
Architect
Architect
Sep 26, 2025 · Backend Development

Refactor Payment Logic: Replace if‑else with Java Enums & Strategy

This article demonstrates how to replace cumbersome if‑else chains in payment processing with Java enums that encapsulate behavior, leveraging functional interfaces, the strategy pattern, and Spring integration to achieve cleaner, extensible, and testable code while adhering to the Open/Closed principle.

Design PrinciplesEnumSpring
0 likes · 10 min read
Refactor Payment Logic: Replace if‑else with Java Enums & Strategy
21CTO
21CTO
Sep 25, 2025 · Fundamentals

Master Python Coding Standards: 50 Essential Best Practices for Clean, Maintainable Code

This comprehensive guide presents 50 practical Python coding best‑practice rules covering naming, function design, object‑oriented principles, exception handling, code style, and project structure, showing how to write self‑explanatory, reusable, and robust code that stands the test of time and team collaboration.

PythonSoftware Designclean code
0 likes · 25 min read
Master Python Coding Standards: 50 Essential Best Practices for Clean, Maintainable Code
Su San Talks Tech
Su San Talks Tech
Sep 10, 2025 · Fundamentals

15 Proven Code Refactoring Techniques to Supercharge Your Java Projects

Learn 15 practical code refactoring techniques—from extracting methods and introducing explanatory variables to applying design patterns like Strategy and Builder—that transform tangled Java code into clean, modular, and maintainable solutions, boosting readability and simplifying future enhancements.

Code RefactoringDesign Patternsclean code
0 likes · 30 min read
15 Proven Code Refactoring Techniques to Supercharge Your Java Projects
Shepherd Advanced Notes
Shepherd Advanced Notes
Jul 2, 2025 · Fundamentals

45 Tips for Writing Clean, Beautiful Code

This article presents 45 practical coding tips—from naming conventions and formatting to exception handling, thread safety, and design patterns—illustrated with Java examples and real‑world scenarios, helping developers produce readable, maintainable, and robust code.

Design PatternsThread Safetybest practices
0 likes · 29 min read
45 Tips for Writing Clean, Beautiful Code
Baidu Geek Talk
Baidu Geek Talk
May 21, 2025 · Backend Development

Applying Domain‑Driven Design to Build Maintainable and Scalable Backend Architecture

This article explains how the increasing complexity of business logic in modern backend systems leads to tangled code, and demonstrates how strategic and tactical Domain‑Driven Design (DDD) concepts—such as bounded contexts, aggregates, entities, value objects, repositories, and application services—can decouple business and technology, improve maintainability, extensibility, and stability, and guide practical layered architecture implementation.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 30 min read
Applying Domain‑Driven Design to Build Maintainable and Scalable Backend Architecture
macrozheng
macrozheng
Apr 9, 2025 · Fundamentals

Why Clean Code Matters: Practical Tips for Naming, Classes, Functions & Testing

This article explains why clean code is essential for productivity and team collaboration, outlines concrete guidelines for meaningful naming, single‑responsibility classes, concise functions, and effective testing, and shows how tools and refactoring can help maintain high code quality.

Software Designbest practicesclean code
0 likes · 14 min read
Why Clean Code Matters: Practical Tips for Naming, Classes, Functions & Testing
Java Captain
Java Captain
Apr 7, 2025 · Fundamentals

Effective Object Naming: Avoiding “-er”/“-or” Suffixes, God Classes, and Building Intelligent Domain Objects

This article explains why thoughtful object naming—avoiding generic “er”/“or” suffixes and vague Service/Helper classes—improves code readability, maintainability, and AI‑assisted development, and demonstrates better designs with concrete C# examples that model real‑world business roles and adaptive behavior.

AI-assisted programmingSoftware Designclean code
0 likes · 12 min read
Effective Object Naming: Avoiding “-er”/“-or” Suffixes, God Classes, and Building Intelligent Domain Objects
Selected Java Interview Questions
Selected Java Interview Questions
Apr 3, 2025 · Fundamentals

How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing

This article explains why clean code is essential for team development and provides practical guidelines on naming, class design, function composition, and testing—including SOLID principles, meaningful identifiers, single‑responsibility classes, short functions, and test‑driven development—to improve readability, extensibility, and overall software quality.

Software Designclean codenaming conventions
0 likes · 19 min read
How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing
Programmer XiaoFu
Programmer XiaoFu
Apr 1, 2025 · Fundamentals

How a 100k‑Bonus Colleague Writes Elegantly Clean Code

The article explains why clean, well‑structured code matters for team productivity, covering naming, class design, function design, SOLID principles, testing practices such as TDD and the FIRST rule, and shows how tools like SonarLint can help maintain code quality.

SOLIDTDDclean code
0 likes · 17 min read
How a 100k‑Bonus Colleague Writes Elegantly Clean Code
21CTO
21CTO
Feb 2, 2025 · Fundamentals

7 Essential Habits to Transform Your Programming Skills

This article shares seven practical habits—from mastering fundamentals and writing clean code to debugging effectively and building real‑world projects—that help programmers become more skilled, professional, and collaborative in their development journey.

Debuggingclean codelearning documentation
0 likes · 8 min read
7 Essential Habits to Transform Your Programming Skills
BirdNest Tech Talk
BirdNest Tech Talk
Jan 14, 2025 · Fundamentals

Master Go Naming: 30+ Rules for Clean, Idiomatic Code

This article presents a comprehensive, step‑by‑step analysis of Go naming conventions, explaining why each rule matters, illustrating each point with concrete code snippets and real‑world examples, and showing how to apply the guidelines to variables, functions, packages, structs, interfaces, errors, constants, enums and comments for truly clean Go code.

Gobest practicesclean code
0 likes · 24 min read
Master Go Naming: 30+ Rules for Clean, Idiomatic Code
JD Retail Technology
JD Retail Technology
Jan 10, 2025 · Fundamentals

Clean Code: Principles and Practices for Writing Maintainable Software

The article argues that clean code—characterized by readable naming, minimal comments, short single‑purpose functions, simple control flow, and well‑encapsulated classes—is essential for maintainable software, contrasting it with design patterns and architecture, and demonstrates its benefits through practical refactoring examples and a real‑world case study.

Software Engineeringbest practicesclean code
0 likes · 20 min read
Clean Code: Principles and Practices for Writing Maintainable Software
Top Architecture Tech Stack
Top Architecture Tech Stack
Dec 9, 2024 · Fundamentals

Performance Impact of Clean Code Practices: A C++ Case Study

This article examines how strict adherence to clean‑code principles in C++—such as using polymorphism, limiting function size, and avoiding internal knowledge—affects runtime performance, comparing virtual‑function hierarchies, switch‑based implementations, and table‑driven approaches, and revealing up to fifteen‑fold speed differences.

C++clean codepolymorphism
0 likes · 21 min read
Performance Impact of Clean Code Practices: A C++ Case Study
php Courses
php Courses
Nov 5, 2024 · Backend Development

Five Essential Rules for Writing Clean PHP Code

This article presents five fundamental guidelines—including clear naming, single‑responsibility functions, consistent style, SOLID principles, and self‑documenting code—along with PHP code examples to help developers produce more readable, maintainable, and extensible applications.

OOPPHPSOLID
0 likes · 4 min read
Five Essential Rules for Writing Clean PHP Code
21CTO
21CTO
Oct 11, 2024 · Fundamentals

From Messy to Clean: Transform Your Code with Simple Best Practices

This article shares a developer’s journey from tangled, hard‑to‑read code to clean, maintainable software, illustrating how meaningful naming, PEP 8 compliance, static typing, small functions, avoiding magic numbers, and the DRY principle can dramatically improve code quality.

DRYbest practicesclean code
0 likes · 9 min read
From Messy to Clean: Transform Your Code with Simple Best Practices
Java Tech Enthusiast
Java Tech Enthusiast
Jul 30, 2024 · Fundamentals

Best Practices for Clean Code Naming and Structure

Clean code demands readable, extensible structures and precise, unambiguous naming—each class, method, and variable should convey a single responsibility, avoid duplication, and follow consistent conventions, enabling easy testing, maintenance, and team collaboration while preventing the productivity‑draining chaos of poorly named, tangled code.

Software Engineeringbest practicesclean code
0 likes · 18 min read
Best Practices for Clean Code Naming and Structure
Top Architect
Top Architect
Jul 15, 2024 · Fundamentals

Clean Code Practices: Naming, Classes, Functions, and Testing

This article explains why maintaining clean, well‑structured code is essential for productivity and team collaboration, covering naming conventions, class design principles, function responsibilities, testing strategies, and tools like SonarLint, while providing concrete Java code examples for each concept.

Software Designclean codenaming conventions
0 likes · 16 min read
Clean Code Practices: Naming, Classes, Functions, and Testing
Architect
Architect
Jul 8, 2024 · Fundamentals

Master Clean Code: Naming, Classes, Functions, and Testing Best Practices

This guide explains why clean code matters, outlines practical naming conventions, class design principles, function structuring rules, and testing strategies—including TDD, the FIRST criteria, and automated test generation—to help developers write maintainable, readable, and high‑quality software.

SOLID principlesTDDclean code
0 likes · 16 min read
Master Clean Code: Naming, Classes, Functions, and Testing Best Practices
macrozheng
macrozheng
Jun 29, 2024 · Fundamentals

Master Clean Code: Proven Naming Conventions Every Developer Should Follow

This article explains why clean, well‑named code is essential for productivity, outlines practical naming rules—such as avoiding ambiguity, preventing misleading names, making meaningful distinctions, and keeping identifiers searchable—and provides concrete Java examples and patterns to help developers write maintainable, testable software.

Software Designclean codecode readability
0 likes · 18 min read
Master Clean Code: Proven Naming Conventions Every Developer Should Follow
macrozheng
macrozheng
Jun 24, 2024 · Fundamentals

How to Keep Your Code Clean During Rapid Development

The article shares practical lessons on maintaining code quality and readability amid intense project iterations, emphasizing thorough code reviews, incremental refactoring, and the importance of a shared coding style to prevent technical debt and the broken‑window effect.

Code ReviewSoftware Engineeringclean code
0 likes · 9 min read
How to Keep Your Code Clean During Rapid Development
Java Tech Enthusiast
Java Tech Enthusiast
May 26, 2024 · Fundamentals

Clean Code Naming Guidelines

Effective clean‑code practices require precise, unambiguous naming for variables, methods, classes, and packages, because clear identifiers convey purpose, avoid confusion, simplify maintenance, reduce bugs, and support readability, extensibility, and testability, ultimately preventing technical debt and improving team productivity.

Software Engineeringbest practicesclean code
0 likes · 17 min read
Clean Code Naming Guidelines
Java Architect Essentials
Java Architect Essentials
May 14, 2024 · Fundamentals

Master Clean Code: Naming, Classes, Functions, and Testing Made Simple

This article explains why clean code is essential for productivity and project health, and provides practical guidance on naming, class design, function design, and testing—including SOLID principles, parameter handling, exception use, and test‑driven development—to help developers write maintainable, high‑quality software.

SOLIDSoftware Designclean code
0 likes · 17 min read
Master Clean Code: Naming, Classes, Functions, and Testing Made Simple
Architecture Digest
Architecture Digest
May 9, 2024 · Fundamentals

Clean Code Practices: Naming, Classes, Functions, and Testing

This article explains why clean code matters for productivity and project health, and provides practical guidelines on naming, class design, function design, SOLID principles, testing strategies, and tooling to help developers write maintainable, readable software.

SOLIDSoftware Designclean code
0 likes · 13 min read
Clean Code Practices: Naming, Classes, Functions, and Testing
Top Architect
Top Architect
May 7, 2024 · Fundamentals

Clean Code Principles: Naming, Classes, Functions, and Testing Practices

This article explains why clean code is essential for productivity and project health, covering naming conventions, class design, SOLID principles, function design, parameter handling, testing strategies like TDD and the FIRST principles, and tools such as SonarLint to maintain code quality.

Software Designclean codenaming conventions
0 likes · 18 min read
Clean Code Principles: Naming, Classes, Functions, and Testing Practices
Java Architect Essentials
Java Architect Essentials
Apr 15, 2024 · Fundamentals

Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines

The article explains why maintaining clean code is essential, covering naming conventions, class design, function principles, and testing strategies, and provides concrete Java examples and refactoring techniques to help developers write readable, maintainable, and high‑quality software.

Single Responsibilityclean codenaming conventions
0 likes · 16 min read
Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines
DaTaobao Tech
DaTaobao Tech
Apr 3, 2024 · Frontend Development

Clean Front-End Architecture for Agile Development

By separating UI components from business logic using a clean, layered architecture inspired by DDD, Hexagonal and Clean Architecture, the article shows how React, zustand hooks, and strict data‑dependency rules reduce coupling, lower development cost, and make agile front‑end code easier to maintain and extend.

FrontendHooksarchitecture
0 likes · 32 min read
Clean Front-End Architecture for Agile Development
Sanyou's Java Diary
Sanyou's Java Diary
Nov 16, 2023 · Fundamentals

Why Readable Code Wins: Practical Tips to Boost Maintainability

This article explores the importance of code readability, comparing simple versus layered implementations, and offers concrete strategies—such as using clear intent, hierarchical structure, concise methods, pure conditions, and minimal comments—to improve maintainability and reduce side effects in everyday software development.

best practicesclean codecode readability
0 likes · 14 min read
Why Readable Code Wins: Practical Tips to Boost Maintainability
Su San Talks Tech
Su San Talks Tech
Oct 14, 2023 · Fundamentals

Why Clean Code Matters: Practical Tips for Naming, Classes, Functions & Tests

This comprehensive guide explains why clean code is crucial for productivity and company health, and provides actionable advice on writing clean code through proper naming, class design, function structuring, and testing practices, illustrated with Java examples and refactoring patterns.

SOLID principlesclean codenaming conventions
0 likes · 17 min read
Why Clean Code Matters: Practical Tips for Naming, Classes, Functions & Tests
Architect
Architect
Oct 5, 2023 · Fundamentals

Mastering Clean Code: Naming, Classes, Functions, and Tests Explained

This article explains why clean code matters, demonstrates how meaningful naming, single‑responsibility classes, well‑structured functions, and disciplined testing (TDD and the FIRST principles) improve readability, maintainability, and productivity, using concrete Java examples, refactorings, and step‑by‑step guidelines.

Single ResponsibilitySoftware DesignTDD
0 likes · 17 min read
Mastering Clean Code: Naming, Classes, Functions, and Tests Explained
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 5, 2023 · Frontend Development

Clean Code Practices and Tooling for Frontend Development

This article explains the concepts of external and internal code beauty, introduces essential frontend tooling such as ESLint, Prettier, Stylelint, husky, lint‑staged, EditorConfig, and CSSComb, and shares practical habits on documentation, naming, and commenting to help developers produce elegant, maintainable code.

Code styleESLintFrontend
0 likes · 13 min read
Clean Code Practices and Tooling for Frontend Development
Java High-Performance Architecture
Java High-Performance Architecture
Oct 1, 2023 · Fundamentals

Why Clean Code Matters: Practical Tips to Write Maintainable Java

This article summarizes key lessons from 'Clean Code', explaining why maintaining clean, readable Java code boosts productivity, reduces bugs and costs, and detailing practical guidelines for naming, class design, functions, testing, and refactoring to help developers write high‑quality, maintainable software.

Software Designclean codecoding standards
0 likes · 15 min read
Why Clean Code Matters: Practical Tips to Write Maintainable Java
Architecture Digest
Architecture Digest
Sep 28, 2023 · Fundamentals

How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing

This article explains why clean code is essential for productivity and team collaboration, and provides practical guidelines on naming, class design, function design, and testing—including principles like single responsibility, SOLID, meaningful naming, minimal parameters, and test‑driven development—to help developers produce readable, extensible, and reliable software.

SOLIDSoftware Designclean code
0 likes · 14 min read
How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing
Java Architect Essentials
Java Architect Essentials
Sep 27, 2023 · Fundamentals

How to Write Clean Code: Naming, Classes, Functions, and Testing Best Practices

This article explains why clean code is essential for productivity and business health, and provides practical guidelines on naming, class design, function design, and testing—including code examples, refactoring techniques, and quality‑checking tools—to help developers produce readable, maintainable, and extensible software.

Software DesignTDDclean code
0 likes · 14 min read
How to Write Clean Code: Naming, Classes, Functions, and Testing Best Practices
Top Architect
Top Architect
Sep 22, 2023 · Fundamentals

Clean Code Principles: Naming, Classes, Functions, and Testing Best Practices

This article summarizes key clean‑code practices—including the importance of readable naming, adhering to SOLID principles for classes, writing single‑purpose functions, avoiding redundant parameters, and employing test‑driven development and code‑quality tools—to help developers produce maintainable, extensible software.

SOLIDbest practicesclean code
0 likes · 22 min read
Clean Code Principles: Naming, Classes, Functions, and Testing Best Practices
21CTO
21CTO
Sep 18, 2023 · Fundamentals

How to Write Clean, Maintainable Code: 10 Essential Practices

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
How to Write Clean, Maintainable Code: 10 Essential Practices
Su San Talks Tech
Su San Talks Tech
Aug 20, 2023 · Fundamentals

How to Keep Code Clean During Rapid Java Backend Iterations

The author shares personal experiences of rushed code reviews in a busy Java micro‑service team, highlights the loss of code ownership, discusses common code smells, and explains how disciplined reviews and incremental refactoring can restore readability and maintainability.

Code ReviewSoftware Engineeringclean code
0 likes · 9 min read
How to Keep Code Clean During Rapid Java Backend Iterations
macrozheng
macrozheng
Aug 5, 2023 · Fundamentals

Why Code Reviews Fail and How Refactoring Can Rescue Your Project

The author reflects on rushed code reviews during intense development cycles, explains how neglecting thorough reviews leads to loss of code ownership, and advocates systematic reviews, continuous refactoring, and clean‑code practices to maintain project health and improve team collaboration.

Code ReviewSoftware Engineeringbest practices
0 likes · 9 min read
Why Code Reviews Fail and How Refactoring Can Rescue Your Project
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 29, 2023 · Fundamentals

Can You Write Clean Code Without Comments? Strategies to Eliminate Bad Annotations

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.

Software Engineeringclean codecode comments
0 likes · 7 min read
Can You Write Clean Code Without Comments? Strategies to Eliminate Bad Annotations
JD Retail Technology
JD Retail Technology
Apr 3, 2023 · Fundamentals

How to Master Clean Code: From Learning to Refactoring with Real Examples

This article explores a systematic approach to becoming a better programmer, covering learning mindset, selecting role models, applying knowledge, coding principles, performance considerations, and refactoring techniques, illustrated with a RocketMQ file‑prewarm case study and practical guidelines for writing maintainable, high‑quality code.

LearningRocketMQSoftware Engineering
0 likes · 17 min read
How to Master Clean Code: From Learning to Refactoring with Real Examples
Architecture Digest
Architecture Digest
Mar 6, 2023 · Fundamentals

The Performance Cost of Clean Code: How Following Clean‑Code Rules Can Slow Down Your Program

This article examines how strict adherence to clean‑code principles—such as using polymorphism, keeping functions tiny, and avoiding switch statements—can dramatically increase the number of CPU cycles required for simple area‑calculation loops, presenting benchmark results that show performance penalties of up to fifteen‑fold.

C++benchmarkclean code
0 likes · 20 min read
The Performance Cost of Clean Code: How Following Clean‑Code Rules Can Slow Down Your Program
Programmer DD
Programmer DD
Mar 3, 2023 · Fundamentals

Why Clean Code Can Slow Your C++ Programs by 15× – A Performance Deep Dive

An extensive performance analysis shows that strictly following clean‑code rules—such as using polymorphism, avoiding switch statements, and keeping functions tiny—can dramatically increase execution time, with measured slowdowns up to fifteen times, while alternative table‑driven or flat‑structure approaches achieve orders‑of‑magnitude speed gains.

C++Optimizationclean code
0 likes · 24 min read
Why Clean Code Can Slow Your C++ Programs by 15× – A Performance Deep Dive
Top Architect
Top Architect
Mar 1, 2023 · Fundamentals

Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines

This article explains why clean code is essential for productivity, outlines naming conventions, class design, SOLID principles, function responsibilities, parameter handling, and testing practices such as TDD and the FIRST principles, providing concrete examples and refactoring snippets to help developers write maintainable, high‑quality software.

Software Designclean codetesting
0 likes · 15 min read
Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines
High Availability Architecture
High Availability Architecture
Feb 23, 2023 · Backend Development

Clean Code Principles and Practical Java Refactoring Guidelines

This article presents a comprehensive guide to improving Java code quality by emphasizing simplicity, leveraging language features, consolidating similar logic, and structuring APIs to clearly distinguish required and optional parameters, illustrated with side‑by‑side bad and good implementations and practical recommendations.

clean codejavarefactoring
0 likes · 13 min read
Clean Code Principles and Practical Java Refactoring Guidelines
Alibaba Cloud Developer
Alibaba Cloud Developer
Feb 23, 2023 · Fundamentals

Why Refactoring Matters: Lessons from "Refactoring" for New Engineers

The article reviews the book “Refactoring: Improving the Design of Existing Code”, explains what refactoring is, why it is essential for maintainability and efficiency, and presents practical techniques—such as removing duplicate code, improving naming, simplifying conditions, and using enums—to help engineers with one‑year experience write cleaner, more maintainable Java code.

Software Engineeringclean codecode quality
0 likes · 17 min read
Why Refactoring Matters: Lessons from "Refactoring" for New Engineers
JD Tech
JD Tech
Feb 16, 2023 · Fundamentals

Principles of Clean Code: Theory and Practical Comparisons in Java

This article presents a theoretical framework for clean code, compares poor and excellent Java implementations across several scenarios, and offers practical recommendations to simplify code, leverage language features, and maintain clear business logic, emphasizing the core philosophy of "the greatest simplicity".

Code Refactoringbest practicesclean code
0 likes · 12 min read
Principles of Clean Code: Theory and Practical Comparisons in Java
Top Architect
Top Architect
Feb 8, 2023 · Fundamentals

Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines

This article explains why clean code matters and provides practical guidelines on naming, class design, function decomposition, SOLID principles, testing strategies such as TDD and FIRST, as well as tooling like SonarLint to improve code quality and maintainability.

SOLID principlesSoftware Designclean code
0 likes · 18 min read
Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines
macrozheng
macrozheng
Feb 3, 2023 · Fundamentals

Why Clean Code Matters: Practical Tips for Naming, Classes, Functions, and Tests

This article explains why clean, well‑structured code is essential for productivity and project success, and provides concrete guidance on naming, class design, function composition, testing practices, and tools to help developers write maintainable, high‑quality software.

Software Designbest practicesclean code
0 likes · 13 min read
Why Clean Code Matters: Practical Tips for Naming, Classes, Functions, and Tests
MaGe Linux Operations
MaGe Linux Operations
Jan 26, 2023 · Fundamentals

How Clean Code Principles Transform Your Programming Practice

This article reflects on key insights from Robert Martin’s *Clean Code*, covering the distinction between dirty and clean code, the art of naming, effective commenting, function design principles, and the essential role of testing, offering practical examples and personal reflections for writing more readable, maintainable software.

Namingclean codefunction design
0 likes · 12 min read
How Clean Code Principles Transform Your Programming Practice
政采云技术
政采云技术
Dec 22, 2022 · Fundamentals

Understanding Refactoring: Motivation, Standards, and a Practical Java Example

This article explains why refactoring is essential for maintainable code, outlines quality standards such as readability and extensibility, and walks through a concrete Java example that evolves from a monolithic statement method to a clean, modular design using extract method, move method, and replace‑temp‑with‑query techniques.

Software Designclean codecode quality
0 likes · 16 min read
Understanding Refactoring: Motivation, Standards, and a Practical Java Example
21CTO
21CTO
Dec 6, 2022 · Fundamentals

Master the 23 Core Software Architecture Principles Every Engineer Should Know

This article presents a concise overview of 23 essential software architecture principles—from Dependency Inversion and Separation of Concerns to Bounded Context and KISS—explaining each concept, its practical impact, and providing code examples to help developers design clean, maintainable systems.

Design PrinciplesSOLIDclean code
0 likes · 12 min read
Master the 23 Core Software Architecture Principles Every Engineer Should Know
Top Architect
Top Architect
Dec 5, 2022 · Fundamentals

Essential Software Architecture Principles Explained by a Senior Architect

The article presents a concise overview of core software architecture principles—including Dependency Inversion, Separation of Concerns, Inversion of Control, Dependency Injection, Single Responsibility, DRY, Open‑Closed, and many others—supplemented with Java code examples and references for deeper study.

Dependency InversionDesign PrinciplesInversion of Control
0 likes · 12 min read
Essential Software Architecture Principles Explained by a Senior Architect
21CTO
21CTO
Dec 1, 2022 · Frontend Development

Say Goodbye to Bad JavaScript Practices: 8 Essential Tips for Clean Code

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.

JavaScriptclean codecode comments
0 likes · 7 min read
Say Goodbye to Bad JavaScript Practices: 8 Essential Tips for Clean Code
21CTO
21CTO
Nov 17, 2022 · Fundamentals

Why Clean Code Principles Matter for Every Developer

This article shares practical takeaways from the book "Clean Code", covering why messy code hurts productivity, how to name variables and functions better, essential class design rules, error handling, refactoring tips, and a brief look at concurrency and iterative development.

Software Designclean codecoding standards
0 likes · 9 min read
Why Clean Code Principles Matter for Every Developer
Sohu Tech Products
Sohu Tech Products
Sep 7, 2022 · Fundamentals

Refactoring Techniques: Extract Function, Parameterize, Strategy Pattern, and More

This article presents a series of refactoring techniques—including extracting functions, parameterizing functions, applying the strategy pattern, extracting variables, splitting loops, and using guard clauses—illustrated with JavaScript code examples to improve readability, maintainability, and modularity of existing code bases.

Software Engineeringclean coderefactoring
0 likes · 15 min read
Refactoring Techniques: Extract Function, Parameterize, Strategy Pattern, and More
IT Architects Alliance
IT Architects Alliance
Sep 3, 2022 · Fundamentals

Key Programming Principles: KISS, DRY, YAGNI, and More

This article presents a concise collection of essential programming principles—including KISS, DRY, YAGNI, writing code for maintainers, lazy development, and testing discipline—explaining their origins, practical applications, and how they help developers produce simpler, more maintainable, and higher‑quality software.

DRYKISSYAGNI
0 likes · 12 min read
Key Programming Principles: KISS, DRY, YAGNI, and More
Alibaba Terminal Technology
Alibaba Terminal Technology
Jun 14, 2022 · Fundamentals

Why Code Comments Matter: Balancing Documentation and Clean Code

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.

Software Designbest practicesclean code
0 likes · 21 min read
Why Code Comments Matter: Balancing Documentation and Clean Code
ITPUB
ITPUB
Mar 21, 2022 · Fundamentals

How to Tame Software Complexity: Entropy, Constructal Law, and Design Strategies

This article explores why software systems inevitably become more entropic and complex, draws parallels with physical entropy and the Constructal Law, identifies sources of uncertainty, scale, and cognitive cost, and presents practical approaches such as isolating core kernels, adopting Domain‑Driven Design, and applying Clean Code principles to keep systems maintainable.

Anemic ModelRich Domain Modelclean code
0 likes · 18 min read
How to Tame Software Complexity: Entropy, Constructal Law, and Design Strategies
Java High-Performance Architecture
Java High-Performance Architecture
Feb 16, 2022 · Fundamentals

How to Write Clean Code: Naming, Comments, Functions, and Testing Best Practices

This article explores the core principles of clean code—including effective naming, purposeful comments, single‑responsibility functions, proper abstraction levels, and essential testing practices—illustrated with concrete code examples and actionable guidelines for writing more readable, maintainable software.

NamingSoftware Engineeringclean code
0 likes · 10 min read
How to Write Clean Code: Naming, Comments, Functions, and Testing Best Practices
Architecture Digest
Architecture Digest
Feb 15, 2022 · Fundamentals

Principles of Clean Code: Naming, Functions, and Testing

This article distills key lessons from the book "Clean Code", covering expressive naming, purposeful functions, minimal and meaningful comments, and rigorous testing practices, illustrated with concrete code examples to help developers write more readable and maintainable software.

Namingclean codecode quality
0 likes · 10 min read
Principles of Clean Code: Naming, Functions, and Testing
Liangxu Linux
Liangxu Linux
Dec 1, 2021 · Fundamentals

Master Essential Software Design Principles: From KISS to SOLID

This article explains core software design principles—including KISS, DRY, high cohesion/low coupling, separation of concerns, YAGNI, the Boy‑Scout rule, and the SOLID rules—detailing their motivations, practical guidelines, benefits, and common pitfalls for creating maintainable, flexible code.

DRYKISSSOLID
0 likes · 27 min read
Master Essential Software Design Principles: From KISS to SOLID
Code Ape Tech Column
Code Ape Tech Column
Nov 22, 2021 · Fundamentals

25 Common Code Smells and Their Refactoring Solutions

This article explains twenty‑five typical code smells—such as duplicated code, long methods, large classes, and excessive parameters—and provides concrete refactoring techniques like Extract Method, Extract Class, and Move Method to improve readability, maintainability, and design quality in object‑oriented software.

Object-OrientedSoftware Designclean code
0 likes · 19 min read
25 Common Code Smells and Their Refactoring Solutions
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 29, 2021 · Fundamentals

25 Common Code Smells and Their Refactoring Solutions

This article lists 25 typical code smells—such as duplicated code, long methods, large classes, and magic numbers—explains why they hinder readability and maintainability, and provides concrete refactoring solutions with Java examples to improve code quality and design.

Software Designclean codecode smells
0 likes · 17 min read
25 Common Code Smells and Their Refactoring Solutions
ITPUB
ITPUB
Sep 7, 2021 · Fundamentals

How to Write Clean, Maintainable Code: Principles and Practical Tips

This article compiles practical guidelines and personal experiences on writing clean, maintainable code, covering principles such as eliminating duplication, separating concerns, unifying abstraction levels, function design, naming, unit testing, and broader software‑engineering concepts to reduce mental load and improve code quality.

Software Designabstractionclean code
0 likes · 24 min read
How to Write Clean, Maintainable Code: Principles and Practical Tips
Qunar Tech Salon
Qunar Tech Salon
Aug 5, 2021 · Fundamentals

Four Types of Code Hygiene: Understanding Programmers' Clean‑Code Habits

The article describes four distinct code‑hygiene personalities—Minimalist, Distance‑Creates‑Beauty, Precise‑Constraint, and Creative‑Craft—explaining how each habit improves code readability, reduces technical debt, and ultimately boosts team efficiency in software projects.

clean codecode hygieneprogramming habits
0 likes · 2 min read
Four Types of Code Hygiene: Understanding Programmers' Clean‑Code Habits
Wukong Talks Architecture
Wukong Talks Architecture
Jul 12, 2021 · Fundamentals

25 Common Code Smells and Refactoring Techniques

This article lists 25 typical code smells such as duplicated code, long methods, large classes, and provides concrete Java examples and refactoring strategies like Extract Method, Extract Class, Move Method, and design recommendations to improve readability, maintainability, and extensibility.

Software Designbad practiceclean code
0 likes · 23 min read
25 Common Code Smells and Refactoring Techniques
ELab Team
ELab Team
Jul 8, 2021 · Frontend Development

How Clean Code Practices Supercharge Your JavaScript Projects

This article explores the importance of clean code in JavaScript, presenting the 3R software design principles, naming conventions, function design, component best practices, and practical refactorings with before‑and‑after code examples to help developers write more readable, reusable, and maintainable frontend code.

best practicesclean coderefactoring
0 likes · 15 min read
How Clean Code Practices Supercharge Your JavaScript Projects
KooFE Frontend Team
KooFE Frontend Team
Jun 14, 2021 · Fundamentals

How to Write Clean, Readable JavaScript Code: Essential Practices

This article explores the core concepts of clean code for JavaScript, covering code smells, technical debt, refactoring, readability, writing code in English, and team collaboration techniques, while providing practical examples and tooling tips for maintaining high‑quality code.

clean codecode readabilityrefactoring
0 likes · 11 min read
How to Write Clean, Readable JavaScript Code: Essential Practices
KooFE Frontend Team
KooFE Frontend Team
Jun 1, 2021 · Frontend Development

Master Variable Naming: Clean Code Practices for JavaScript

This article explains essential clean‑code techniques for naming variables in JavaScript/TypeScript, covering self‑descriptive, pronounceable identifiers, avoiding type prefixes, using consistent terminology, eliminating unnecessary context, and replacing magic numbers and strings with meaningful constants.

JavaScriptSoftware Engineeringbest practices
0 likes · 10 min read
Master Variable Naming: Clean Code Practices for JavaScript
KooFE Frontend Team
KooFE Frontend Team
May 12, 2021 · Fundamentals

How to Eliminate Complex Conditionals for Cleaner JavaScript Code

This article explains why complex conditional statements hurt code readability and maintainability, and provides practical techniques—such as avoiding flag parameters, encapsulating conditions, using guard clauses, applying the Null Object pattern, leveraging polymorphism, and employing strategy or command patterns—to simplify JavaScript/TypeScript code and improve overall quality.

Software DesignTypeScriptclean code
0 likes · 8 min read
How to Eliminate Complex Conditionals for Cleaner JavaScript Code
KooFE Frontend Team
KooFE Frontend Team
May 6, 2021 · Fundamentals

When Are Code Comments Helpful? Best Practices for Clean JavaScript

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.

JavaScriptbest practicesclean code
0 likes · 7 min read
When Are Code Comments Helpful? Best Practices for Clean JavaScript
KooFE Frontend Team
KooFE Frontend Team
Apr 28, 2021 · Fundamentals

How to Write Clean, Maintainable Functions: Practical Tips & Examples

This article presents essential clean‑code techniques for writing reusable, side‑effect‑free functions—covering default parameters, limiting arguments, avoiding global state and mutable objects, single‑purpose design, abstraction levels, functional over imperative styles, and method chaining—illustrated with clear JavaScript examples.

Functional Programmingbest practicesclean code
0 likes · 13 min read
How to Write Clean, Maintainable Functions: Practical Tips & Examples
ITPUB
ITPUB
Mar 24, 2021 · Fundamentals

Mastering Code Review: 12 Principles for Writing Clean, Maintainable Go Code

This article shares a senior engineer's practical philosophy on code review, covering why reviews matter, common pitfalls like duplicated code and premature optimization, and twelve concrete principles—such as simplicity, composition, transparency, and early returns—to help developers write clearer, more maintainable Go programs.

Code ReviewDesign PrinciplesSoftware Engineering
0 likes · 41 min read
Mastering Code Review: 12 Principles for Writing Clean, Maintainable Go Code
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Mar 10, 2021 · Fundamentals

Mastering Clean Code: SOLID Principles, Architecture Patterns, and Naming Strategies

This article distills essential software design knowledge—covering the five SOLID principles, three common architecture styles, effective diagramming, naming conventions, and techniques for simplifying nested if‑else logic—providing concrete Python examples and visual aids to help developers write more maintainable and robust code.

Design PatternsPythonclean code
0 likes · 22 min read
Mastering Clean Code: SOLID Principles, Architecture Patterns, and Naming Strategies
Laravel Tech Community
Laravel Tech Community
Feb 21, 2021 · Frontend Development

Refactoring Examples for Dependent Requests and Complex If‑Else Logic in JavaScript

This article presents practical refactoring techniques for JavaScript code, illustrating how to replace callback‑hell request chains with Promise.all and async/await, transform tangled if‑else blocks into pure, modular functions, and adopt clean‑code principles to improve readability, testability, and maintainability.

FrontendJavaScriptPromise
0 likes · 10 min read
Refactoring Examples for Dependent Requests and Complex If‑Else Logic in JavaScript