BestHub
Sign in
Tagged articles

code quality

542 articles · Page 4 of 6
Taobao Frontend Technology
Taobao Frontend Technology
Mar 1, 2022 · Frontend Development

How Taobao Transformed Its Store Builder with TypeScript: Lessons & Best Practices

This article details Taobao's front‑end engineer Lin Weixuan's experience migrating the massive store‑decoration codebase to TypeScript, establishing development and engineering standards, optimizing compiler performance, and exploring advanced type programming and tooling to improve code quality and stability.

MigrationUtility Typescode quality
0 likes · 40 min read
How Taobao Transformed Its Store Builder with TypeScript: Lessons & Best Practices
Java Interview Crash Guide
Java Interview Crash Guide
Feb 17, 2022 · Backend Development

Boost Your Java Backend: Practical Coding Habits and Best Practices

This article shares a collection of practical Java backend coding habits—from using @ConfigurationProperties and @RequiredArgsConstructor, to modularizing code, handling exceptions, minimizing database queries, managing thread pools, naming caches, applying design patterns, and leveraging asynchronous tasks—to improve code quality and performance.

Thread Poolcode qualityjava
0 likes · 11 min read
Boost Your Java Backend: Practical Coding Habits and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Feb 16, 2022 · Backend Development

Java Backend Development Best Practices and Tips

This article presents a collection of practical Java backend development guidelines, covering configuration management with @ConfigurationProperties, constructor injection via @RequiredArgsConstructor, code modularization, exception handling, database query reduction, null avoidance, strategic use of design patterns, IDE assistance, source code reading, and fundamental coding techniques such as map traversal and collection choice.

ConfigurationSpringbest practices
0 likes · 7 min read
Java Backend Development Best Practices and Tips
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
IT Services Circle
IT Services Circle
Feb 14, 2022 · Backend Development

20 Common Coding Pitfalls and How to Avoid Them

This article lists twenty typical coding mistakes that developers often encounter, such as poor formatting, unclear naming, duplicated code, long methods, excessive nesting, hard‑coded values, improper logging, and missing tests, and provides practical refactoring techniques and best‑practice recommendations to improve code quality and maintainability.

code qualitycoding best practicesjava
0 likes · 32 min read
20 Common Coding Pitfalls and How to Avoid Them
Su San Talks Tech
Su San Talks Tech
Feb 8, 2022 · Fundamentals

20 Code Smells That Drive Developers Crazy (And How to Fix Them)

This article explores twenty common coding pitfalls—from poor formatting and meaningless naming to deep nesting, hard‑coding, and missing unit tests—offering practical refactoring tips, design‑pattern solutions, and best‑practice guidelines to improve code readability, maintainability, and performance.

Software Engineeringbest practicescode quality
0 likes · 38 min read
20 Code Smells That Drive Developers Crazy (And How to Fix Them)
dbaplus Community
dbaplus Community
Feb 4, 2022 · Fundamentals

20 Bad Programmer Habits to Avoid for a Stronger Career

This article outlines twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting official docs and inadequate testing—explaining why they hinder growth and offering concrete advice on how to develop professional coding, communication, and teamwork skills.

Software Engineeringcode qualitycommunication
0 likes · 10 min read
20 Bad Programmer Habits to Avoid for a Stronger Career
Tencent Cloud Developer
Tencent Cloud Developer
Jan 18, 2022 · Frontend Development

Writing Reusable Code: Principles and Practices for Front-End Development

Writing reusable front‑end code means identifying and extracting repeatable UI components, centralized API request/response handling, common business‑flow logic, shared state management, and utility functions into separate, modular files or libraries, which reduces duplication, eases maintenance, and improves scalability across similar scenarios.

FrontendHooksReAct
0 likes · 7 min read
Writing Reusable Code: Principles and Practices for Front-End Development
Java Backend Technology
Java Backend Technology
Jan 16, 2022 · Backend Development

Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips

This article presents a comprehensive guide to building maintainable, extensible backend systems by covering coding conventions, branch naming, commit messages, comment standards, result‑wrapping patterns, database normalization, algorithmic improvements, concurrency handling, service layering, and practical code examples.

Database Designbackendcode quality
0 likes · 20 min read
Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips
Java High-Performance Architecture
Java High-Performance Architecture
Jan 14, 2022 · Fundamentals

30 Hilariously Bad Code Snippets Every Developer Should Avoid

The article humorously showcases a collection of the worst code snippets ever written, illustrating common pitfalls such as reinventing the wheel, magic numbers, unreadable variable names, misuse of booleans, and overly complex switch statements, while reminding developers that everyone writes imperfect code at times.

bad codecode qualitycoding mistakes
0 likes · 5 min read
30 Hilariously Bad Code Snippets Every Developer Should Avoid
Architecture Digest
Architecture Digest
Jan 6, 2022 · Fundamentals

A Collection of the Worst Code Snippets: Lessons from Bad Code

This article humorously showcases a curated collection of notoriously bad code snippets, illustrating common pitfalls such as misuse of boolean logic, magic numbers, poorly named variables, and overly complex switch statements, while encouraging developers to reflect on and improve their coding practices.

bad codecode qualitycoding fundamentals
0 likes · 8 min read
A Collection of the Worst Code Snippets: Lessons from Bad Code
Java Backend Technology
Java Backend Technology
Jan 6, 2022 · Backend Development

Boost Your Java Productivity: 15 Must-Have IntelliJ IDEA Plugins

This guide presents fifteen essential IntelliJ IDEA plugins—from code completion and shortcut hints to code quality checks and live templates—that dramatically streamline Java development, improve code readability, enforce standards, and boost overall productivity for developers.

Development ToolsIDE pluginsIntelliJ IDEA
0 likes · 6 min read
Boost Your Java Productivity: 15 Must-Have IntelliJ IDEA Plugins
dbaplus Community
dbaplus Community
Jan 1, 2022 · Fundamentals

10 Essential Habits Every Programmer Should Adopt

This article outlines ten practical habits for developers, from relying on official documentation and thorough testing before delivery to effective logging, mastering Git, prioritizing functional implementation over premature optimization, managing requirements, proactively solving project issues, allocating buffer time, hands‑on learning, and improving English for technical growth.

Gitcode qualityprogramming habits
0 likes · 8 min read
10 Essential Habits Every Programmer Should Adopt
Tencent Cloud Developer
Tencent Cloud Developer
Dec 30, 2021 · Frontend Development

How to Write Robust Front-End Code: Practices and Techniques

Writing robust front‑end code involves systematic exception handling, thorough input validation, disciplined code‑style practices such as default cases and optional chaining, careful selection of mature third‑party libraries, and proactive robustness testing like monkey testing to ensure the UI remains functional under unexpected conditions.

FrontendInput ValidationJavaScript
0 likes · 8 min read
How to Write Robust Front-End Code: Practices and Techniques
Efficient Ops
Efficient Ops
Dec 16, 2021 · Operations

Essential Shell Script Coding Standards for Reliable Maintenance

This guide outlines comprehensive shell scripting standards—including why they matter, core principles, file naming, encoding, line length, indentation, naming conventions, comment rules, error handling, and best‑practice patterns—to improve readability, maintainability, and consistency across Bash scripts in production environments.

Shell scriptingbashcode quality
0 likes · 25 min read
Essential Shell Script Coding Standards for Reliable Maintenance
Tencent Cloud Developer
Tencent Cloud Developer
Dec 6, 2021 · Fundamentals

Improving Code Quality: Methods, Priorities, and Stages

The article explains why high‑quality code boosts product and developer success, lists practical practices such as style standards, meaningful naming, testing, CI, reviews and pair programming, and recommends tackling improvements in three stages—first delivering business functionality, then enhancing readability, and finally reducing complexity.

Code ReviewComplexitySoftware Engineering
0 likes · 5 min read
Improving Code Quality: Methods, Priorities, and Stages
Selected Java Interview Questions
Selected Java Interview Questions
Nov 25, 2021 · Frontend Development

Refactoring Examples for Common Business Scenarios: From Callback Hell to Promise.all and Pure Functions

This article demonstrates how to refactor tangled asynchronous request chains and complex if‑else logic in JavaScript by replacing callback hell with Promise.all and async/await, extracting pure helper functions, and applying best‑practice principles to improve readability, testability, and maintainability.

Async/AwaitFrontendJavaScript
0 likes · 11 min read
Refactoring Examples for Common Business Scenarios: From Callback Hell to Promise.all and Pure Functions
macrozheng
macrozheng
Oct 31, 2021 · Fundamentals

20 Bad Programmer Habits to Avoid for a Successful Career

This article lists twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting testing and teamwork—explaining why each harms productivity and offering concrete advice on how to develop professional coding practices.

Software EngineeringTeam Collaborationcareer development
0 likes · 8 min read
20 Bad Programmer Habits to Avoid for a Successful Career
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 30, 2021 · Fundamentals

20 Bad Habits of Programmers and How to Overcome Them

The article outlines twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting official resources and teamwork—explaining why each is detrimental and offering practical advice for cultivating professional competence and collaborative success.

Software EngineeringTeam Collaborationcode quality
0 likes · 10 min read
20 Bad Habits of Programmers and How to Overcome Them
Baidu App Technology
Baidu App Technology
Oct 25, 2021 · Fundamentals

Becoming a True Software Engineer: Reflections on China's Software Industry Development

Reflecting on China’s Programmer’s Day, the author argues that moving from mere developers to true software engineers—by mastering engineering principles, design, project management, and open‑source culture—is essential for upgrading the nation’s 4 million‑strong software workforce and overcoming low‑quality, involutionary development.

China software industryOpen SourceProject Management
0 likes · 5 min read
Becoming a True Software Engineer: Reflections on China's Software Industry Development
Selected Java Interview Questions
Selected Java Interview Questions
Oct 10, 2021 · Fundamentals

Using SonarLint and SonarQube for Java Code Quality Analysis

This guide introduces SonarLint and SonarQube, explains how to install and configure them for Java projects, demonstrates scanning with Maven, and provides additional resources such as Alibaba Java coding conventions and documentation links, helping developers improve code quality and maintainability.

MavenSonarQubeStatic Analysis
0 likes · 5 min read
Using SonarLint and SonarQube for Java Code Quality Analysis
21CTO
21CTO
Sep 26, 2021 · Fundamentals

10 Red Flags That Reveal a Senior Developer Who’s Not Worth Your Time

This article shares ten common behaviors that indicate a seasoned programmer may lack real skill, explains why these habits hurt teams, and offers practical advice on how to recognize and help such developers become more effective contributors.

career advicecode qualityprogrammer habits
0 likes · 11 min read
10 Red Flags That Reveal a Senior Developer Who’s Not Worth Your Time
Java Architect Essentials
Java Architect Essentials
Sep 25, 2021 · Fundamentals

Why Long Classes Are Problematic and How to Refactor Them

The article explains why excessively long classes violate design principles, cause readability and maintenance issues, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and split responsibilities for cleaner, more maintainable code.

IDEASingle ResponsibilitySoftware Design
0 likes · 9 min read
Why Long Classes Are Problematic and How to Refactor Them
Java Architect Essentials
Java Architect Essentials
Sep 21, 2021 · Fundamentals

Coding Standards and Best Practices for Robust Software Development

This article presents a set of coding "military rules" covering topics such as avoiding magic numbers, limiting method parameters, proper resource release, specific exception handling, and precise arithmetic, followed by practical development efficiency tips and resource links for further learning.

Exception HandlingSoftware Engineeringcode quality
0 likes · 9 min read
Coding Standards and Best Practices for Robust Software Development
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 18, 2021 · Fundamentals

How Effective Code Reviews Can Transform Your Team’s Quality

This comprehensive guide explains why code reviews are essential, outlines their benefits and challenges, describes review formats, participants, focus areas, step‑by‑step processes, key operations, principles, and common pitfalls, providing practical advice and examples to help teams improve code quality and collaboration.

Code ReviewSoftware Engineeringbest practices
0 likes · 23 min read
How Effective Code Reviews Can Transform Your Team’s Quality
Architecture Digest
Architecture Digest
Sep 14, 2021 · Fundamentals

Why You Should Avoid Writing Thousand‑Line Classes and How to Refactor Them

The article explains the problems caused by overly long classes—poor readability, difficult extension, redundant code, and violated design principles—and provides a step‑by‑step guide using IntelliJ IDEA to extract redundant code, rename methods, move members, and split responsibilities into new classes for cleaner, maintainable software.

IDEASingle Responsibility PrincipleSoftware Engineering
0 likes · 8 min read
Why You Should Avoid Writing Thousand‑Line Classes and How to Refactor Them
DevOps Cloud Academy
DevOps Cloud Academy
Sep 3, 2021 · Information Security

Understanding SonarQube: Quantifying Software Quality, Rule Types, Severity Levels, and Metrics

This article explains how SonarQube uses static analysis to measure software reliability, maintainability, security, complexity, test coverage and duplication, describes its rule categories, severity levels, issue states, and metric rating scales, and shows why high‑quality code reduces costs and improves safety.

SonarQubecode qualitysoftware metrics
0 likes · 7 min read
Understanding SonarQube: Quantifying Software Quality, Rule Types, Severity Levels, and Metrics
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 19, 2021 · Fundamentals

Why Bad Code Happens and How to Fix It: From Naming to Design Principles

This article analyzes the root causes of low‑quality code—such as poor naming, tangled structure, and weak scalability—then presents practical ways to improve code quality through domain modeling, SOLID design principles, and design patterns, illustrated with real‑world case studies.

Design PatternsDesign PrinciplesDomain modeling
0 likes · 16 min read
Why Bad Code Happens and How to Fix It: From Naming to Design Principles
21CTO
21CTO
Aug 2, 2021 · Fundamentals

Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes

The article examines why many software projects become “rotten” by analyzing four common code‑quality problems—over‑large components, low cohesion, tangled high‑level/low‑level logic, and rampant if‑else—then offers concrete refactoring patterns, design‑pattern applications, and practical tooling to restore maintainability and project success.

Design Patternscode qualitymaintainability
0 likes · 38 min read
Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes
Architect's Tech Stack
Architect's Tech Stack
Aug 1, 2021 · Backend Development

How to Install and Use Popular IntelliJ IDEA Plugins for Java Development

This article introduces IntelliJ IDEA plugin installation methods—online and offline—and provides concise overviews of more than twenty essential plugins, including Lombok, RestfulTool, MyBatis helpers, code quality tools, and visual enhancements, helping Java developers boost productivity and code quality.

IDE pluginsIntelliJ IDEALombok
0 likes · 10 min read
How to Install and Use Popular IntelliJ IDEA Plugins for Java Development
DevOps
DevOps
Jul 26, 2021 · Fundamentals

Preventing Software Degradation with Domain‑Driven Design and the Two‑Hat Refactoring Approach

The article explains how software degradation occurs as systems evolve, why domain‑driven design combined with a two‑step refactoring approach can maintain high‑quality design, and demonstrates these concepts through an e‑commerce payment case study, covering principles like OCP, SRP, and micro‑services.

Design PrinciplesDomain-Driven Designcode quality
0 likes · 21 min read
Preventing Software Degradation with Domain‑Driven Design and the Two‑Hat Refactoring Approach
macrozheng
macrozheng
Jul 12, 2021 · Backend Development

50+ Proven Tips to Slash Bugs in Your Backend Development

This article compiles over fifty practical tips covering database design, code practices, and cache usage to help developers dramatically reduce bugs, improve reliability, and boost overall software quality in everyday backend projects.

bug reductioncache strategycode quality
0 likes · 30 min read
50+ Proven Tips to Slash Bugs in Your Backend Development
macrozheng
macrozheng
Jul 8, 2021 · Backend Development

Why Legacy Code Is Killing Your Productivity—and How to Fix It

The article shares painful real‑world cases of poorly written SQL and Java code, explains how tangled microservice dependencies and missing transactions cripple maintainability, and offers concrete guidelines for clean architecture, modular design, and effective code governance to boost team efficiency.

SQL Optimizationcode qualitysoftware architecture
0 likes · 8 min read
Why Legacy Code Is Killing Your Productivity—and How to Fix It
phodal
phodal
Jun 29, 2021 · R&D Management

How Guarding Turns Architecture Docs into Automated Multi‑Language Tests

Guarding is a Rust‑based, multi‑language architecture‑guard tool that lets you write readable DSL rules to enforce architectural constraints in Java, JavaScript, Rust, Go and more, using Tree‑sitter for parsing, pest for grammar, and a simple CLI that can be integrated via Git hooks, CI pipelines, or editor plugins.

RustTree-sittercode quality
0 likes · 7 min read
How Guarding Turns Architecture Docs into Automated Multi‑Language Tests
Programmer DD
Programmer DD
Jun 27, 2021 · Frontend Development

When Profanity Sneaks into Production Front‑End Code: How to Prevent It

A recent incident where a profane comment accidentally made it into live front‑end code highlights the challenges of maintaining legacy systems, the limitations of current testing practices—especially for night‑mode features—and sparks a discussion on automating checks to catch such issues before release.

FrontendLegacy Systemscode quality
0 likes · 3 min read
When Profanity Sneaks into Production Front‑End Code: How to Prevent It
DevOps Cloud Academy
DevOps Cloud Academy
Jun 15, 2021 · Information Security

Understanding SonarQube: Quantifying Software Quality, Rule Types, Severities, and Metrics

This article explains how SonarQube uses static analysis to measure software reliability, maintainability, security, complexity, test coverage and duplication, describes its rule categories, severity levels, issue states, and quality metrics, and highlights the cost and productivity benefits of high‑quality code.

SonarQubecode qualitysoftware metrics
0 likes · 6 min read
Understanding SonarQube: Quantifying Software Quality, Rule Types, Severities, and Metrics
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 6, 2021 · Fundamentals

Core Software Architecture Principles and Design Guidelines

This article presents a comprehensive overview of essential software architecture principles—including Single Responsibility, Open‑Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, KISS, and others—illustrated with Java code examples and practical advice for building maintainable, extensible backend systems.

Design PrinciplesSOLIDcode quality
0 likes · 17 min read
Core Software Architecture Principles and Design Guidelines
DeWu Technology
DeWu Technology
May 28, 2021 · Fundamentals

Static Code Analysis Tools Introduction

Static code analysis tools such as Checkstyle, FindBugs/SpotBugs, PMD, QAPlug, Alibaba Code Guidelines Plugin, SonarLint, and SonarQube help Java developers enforce style, detect bugs, security flaws, and code smells early, reducing costs, improving reliability, and enabling continuous quality monitoring throughout the software development lifecycle.

Tool Reviewbest practicescode quality
0 likes · 13 min read
Static Code Analysis Tools Introduction
KooFE Frontend Team
KooFE Frontend Team
May 25, 2021 · Frontend Development

Why Ignoring Exceptions Is Killing Your JavaScript Code (And How to Fix It)

This article explains why proper exception handling is essential for high‑quality JavaScript, contrasts using return codes with real exceptions, shows clean versus dirty code examples, and offers practical guidelines such as defining custom exception hierarchies, handling Promise rejections, and providing contextual error information.

Exception HandlingJavaScriptcode quality
0 likes · 10 min read
Why Ignoring Exceptions Is Killing Your JavaScript Code (And How to Fix It)
Java Architect Essentials
Java Architect Essentials
May 16, 2021 · Fundamentals

Code Quality Evaluation Standards and Metrics

The article explains widely used code quality evaluation standards—including coding conventions, readability, maintainability, duplication, and testability—and describes how the @iceworks/doctor tool scores projects across five dimensions to compute an overall quality score.

DuplicationSoftware Engineeringcode quality
0 likes · 7 min read
Code Quality Evaluation Standards and Metrics
Programmer DD
Programmer DD
May 15, 2021 · Fundamentals

Why Refactoring Matters: Master Code Quality with SOLID, Design Patterns, and Best Practices

This article explains why continuous refactoring is essential for maintaining clean, maintainable software, outlines common code smells, introduces SOLID principles and design patterns, and provides practical techniques such as method extraction, composition over inheritance, and test‑driven development to improve code quality.

SOLIDcode qualityrefactoring
0 likes · 44 min read
Why Refactoring Matters: Master Code Quality with SOLID, Design Patterns, and Best Practices
Java Interview Crash Guide
Java Interview Crash Guide
May 8, 2021 · Fundamentals

Why Refactoring Matters: Transform Bad Code into Clean, Maintainable Software

This article explains why continuous refactoring is essential for evolving projects, defines refactoring and its scales, lists common code smells and their impact, and presents practical techniques—including SOLID principles, design patterns, naming conventions, layering, and test‑driven development—to turn messy code into high‑quality, maintainable software.

Design PatternsSOLIDSoftware Engineering
0 likes · 36 min read
Why Refactoring Matters: Transform Bad Code into Clean, Maintainable Software
Programmer DD
Programmer DD
Apr 29, 2021 · Fundamentals

10 Timeless Programming Proverbs Every Developer Should Live By

This article presents ten classic programming proverbs, each paired with an English translation and a detailed explanation that highlights common pitfalls, best‑practice principles, and the broader impact of code quality on software projects and real‑world systems.

code qualityprogrammingproverbs
0 likes · 18 min read
10 Timeless Programming Proverbs Every Developer Should Live By
macrozheng
macrozheng
Apr 24, 2021 · Operations

How a Single Code Change Caused Million-Dollar Loss and What It Taught Me About Release Discipline

A routine release introduced a tiny code change that triggered a massive production outage, causing millions in losses; the team’s swift rollback, post‑mortem analysis, and reflections on code discipline, testing, and process compliance highlight essential lessons for reliable backend operations.

Incident Managementcode qualityrelease process
0 likes · 9 min read
How a Single Code Change Caused Million-Dollar Loss and What It Taught Me About Release Discipline
Programmer DD
Programmer DD
Apr 22, 2021 · Operations

Boost Code Quality with SonarLint, SonarQube, and Alibaba Code Style Plugin

This guide walks you through installing and using SonarLint for on‑the‑fly code smell detection, setting up SonarQube as a centralized quality platform, integrating it with Maven via the sonar‑maven‑plugin, and applying Alibaba's coding standards to achieve measurable improvements in code health.

MavenSonarQubeStatic Analysis
0 likes · 5 min read
Boost Code Quality with SonarLint, SonarQube, and Alibaba Code Style Plugin
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Apr 20, 2021 · Fundamentals

Master Design Patterns: Boost Code Reusability, Readability, and Maintainability

This comprehensive guide explains what design patterns are, why they matter, the fundamentals of object‑oriented programming, ten core SOLID principles, a mnemonic for 23 patterns, and detailed examples of creational, structural, and behavioral patterns with real‑world code snippets to help developers write cleaner, more maintainable software.

Design PatternsSOLID principlescode quality
0 likes · 28 min read
Master Design Patterns: Boost Code Reusability, Readability, and Maintainability
Java Backend Technology
Java Backend Technology
Mar 14, 2021 · Backend Development

Why Banning Lombok Is Misguided: A Technical Rebuttal

This article challenges common objections to Lombok—JDK compatibility, forced adoption, readability concerns, increased coupling, and cost‑benefit trade‑offs—by presenting counter‑arguments and suggesting alternative viewpoints for Java developers.

Dependency ManagementJDKcode quality
0 likes · 6 min read
Why Banning Lombok Is Misguided: A Technical Rebuttal
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
php Courses
php Courses
Feb 3, 2021 · Backend Development

Practical Refactoring Tips for Cleaner PHP Code

This article presents practical refactoring techniques for PHP developers, emphasizing unit testing, bottom‑up restructuring, eliminating magic numbers, using braces, meaningful naming, and leveraging language features, illustrated with real‑world hotel management code examples and concise best‑practice tips.

PHPbest practicescode quality
0 likes · 9 min read
Practical Refactoring Tips for Cleaner PHP Code
JD Cloud Developers
JD Cloud Developers
Feb 1, 2021 · Frontend Development

How EOS-JS Revolutionizes JavaScript Code Quality with AST‑Based Scanning

This article explains how EOS‑JS, a plugin‑based static analysis tool, uses AST pattern matching to enforce JavaScript coding standards across large front‑end teams, offering automatic fixes, multi‑scenario rule sets, seamless integration, and visualized data statistics to improve code quality and maintenance efficiency.

ASTEOS-JSFrontend
0 likes · 11 min read
How EOS-JS Revolutionizes JavaScript Code Quality with AST‑Based Scanning
FunTester
FunTester
Jan 26, 2021 · Fundamentals

Boost Your Test Development Skills: Practical Tips for Code, Automation, and Workflow

This guide offers test developers actionable habits—from writing pseudo‑code and breaking tasks into manageable items to mastering version control, refactoring, commenting, solution hunting, embracing change, and automating repetitive work—to become more efficient and maintainable engineers.

Software EngineeringTest AutomationWorkflow
0 likes · 7 min read
Boost Your Test Development Skills: Practical Tips for Code, Automation, and Workflow
21CTO
21CTO
Jan 22, 2021 · Fundamentals

Mastering Code Review: 12 Principles for Cleaner, Maintainable Code

This article shares practical insights and principles—from the importance of code review to concrete guidelines like KISS, composition, and transparency—helping developers write higher‑quality, easier‑to‑maintain software while avoiding common pitfalls such as duplication, premature optimization, and over‑engineered designs.

Code ReviewDesign PrinciplesSoftware Engineering
0 likes · 44 min read
Mastering Code Review: 12 Principles for Cleaner, Maintainable Code
Java Interview Crash Guide
Java Interview Crash Guide
Jan 18, 2021 · Fundamentals

Why Code Reviews Matter: Boost Quality, Reduce Debt, and Empower Teams

This guide explains why code reviews are essential for maintaining product quality, preventing technical debt, fostering team knowledge sharing, and improving developer skills, while also addressing common challenges, best‑practice processes, and practical examples to help teams implement effective reviews.

Code ReviewTeam Collaborationcode quality
0 likes · 20 min read
Why Code Reviews Matter: Boost Quality, Reduce Debt, and Empower Teams
DevOps Cloud Academy
DevOps Cloud Academy
Jan 12, 2021 · Operations

Resolving Common SonarQube Issues: Data Instability, Rule Configuration, and Project Authorization

This guide explains how to address three frequent SonarQube challenges—unstable data across branches, difficulty assigning custom rule sets to new projects, and project permission management—by creating per‑branch projects, using REST APIs for quality profiles, and applying permission templates via Jenkins integration.

AutomationCI/CDDevOps
0 likes · 7 min read
Resolving Common SonarQube Issues: Data Instability, Rule Configuration, and Project Authorization
Code Ape Tech Column
Code Ape Tech Column
Jan 11, 2021 · Fundamentals

10 Practical Java Refactoring Techniques Every Developer Should Master

This article presents ten concrete Java refactoring techniques—from extracting duplicate code and splitting long methods to optimizing nested conditionals and removing temporary variables—each illustrated with clear before‑and‑after code examples and practical advice for improving code readability and maintainability.

Software Engineeringbest practicescode quality
0 likes · 14 min read
10 Practical Java Refactoring Techniques Every Developer Should Master
Programmer DD
Programmer DD
Jan 7, 2021 · Operations

How to Run JetBrains Qodana for Docker‑Based Code Quality Checks

JetBrains Qodana brings IDE‑level static analysis into CI/CD pipelines, offering Docker images, GitHub Actions, TeamCity plugins, and cloud services to detect errors, security flaws, and code smells for PHP, Java, and Kotlin projects, with easy setup and web‑based reports.

CI/CDDockerJetBrains
0 likes · 4 min read
How to Run JetBrains Qodana for Docker‑Based Code Quality Checks
Java Interview Crash Guide
Java Interview Crash Guide
Jan 6, 2021 · Fundamentals

Why Clean Code Matters: Naming, Functions, and Testing Secrets Revealed

This article explores the core principles of clean code—from effective naming and expressive functions to purposeful comments and rigorous testing—illustrating how disciplined practices like meaningful identifiers, single‑responsibility functions, and the FIRST testing criteria can dramatically improve code readability, maintainability, and reliability.

NamingSoftware Engineeringclean code
0 likes · 10 min read
Why Clean Code Matters: Naming, Functions, and Testing Secrets Revealed
Top Architect
Top Architect
Jan 3, 2021 · Information Security

Top 7 Static Code Analysis Tools: Features, Languages, and Pricing

This article reviews seven popular static code analysis tools, outlining why static analysis matters, each tool's key features, drawbacks, supported languages, and pricing to help developers choose the right solution for improving code quality and security.

DevOpsSASTSoftware tools
0 likes · 11 min read
Top 7 Static Code Analysis Tools: Features, Languages, and Pricing
Byte Quality Assurance Team
Byte Quality Assurance Team
Dec 31, 2020 · Operations

Engineering Practices for Static Code Scanning: Design, Tool Selection, and Implementation

This article explains the concept, requirements, tool selection criteria, comparative analysis of Sonar, Infer and TscanCode, and practical integration steps—including CI pipeline, Jenkins, and project‑management linkage—to demonstrate how static code scanning can be effectively deployed and measured in a production environment.

CI/CDSoftware EngineeringStatic Analysis
0 likes · 6 min read
Engineering Practices for Static Code Scanning: Design, Tool Selection, and Implementation
macrozheng
macrozheng
Dec 30, 2020 · Fundamentals

How to Spot and Eliminate Common Code Smells for Cleaner, More Maintainable Code

This article explores typical code smells such as long methods, God classes, duplicated code, long parameter lists, shotgun surgery, speculative generality, and excessive comments, explaining why they hinder readability and maintainability, and provides practical refactoring techniques and examples to write cleaner, more understandable code.

clean codecode qualitycode smells
0 likes · 13 min read
How to Spot and Eliminate Common Code Smells for Cleaner, More Maintainable Code
macrozheng
macrozheng
Dec 11, 2020 · Fundamentals

10 Toxic Code Patterns That Can Kill Your Career (And How to Fix Them)

This article lists ten common "toxic" Java code patterns—ranging from offensive method names and misleading sorting to hidden performance traps—and explains why they are harmful, how they affect maintainability and runtime, and what clean, efficient alternatives should be used.

Software Engineeringbest practicescode quality
0 likes · 11 min read
10 Toxic Code Patterns That Can Kill Your Career (And How to Fix Them)
21CTO
21CTO
Nov 26, 2020 · Fundamentals

Why Refactoring Matters: A Practical Guide to Cleaner Code

This article explains why refactoring is essential for maintaining legacy systems, defines refactoring as a controlled code‑restructuring technique that preserves observable behavior, and provides a step‑by‑step process—including when to start, when to stop, prerequisites, and practical tactics—to improve code quality and reduce technical debt.

Software Engineeringbest practicesclean code
0 likes · 13 min read
Why Refactoring Matters: A Practical Guide to Cleaner Code
FunTester
FunTester
Nov 20, 2020 · Backend Development

Using SpotBugs and IntelliJ Plugins for Java Static Code Analysis

The article reviews the transition from Jenkins‑based FindBugs scanning to local IntelliJ plugins, evaluates outdated FindBugs‑IDEA and QAPlug‑FindBugs, and recommends SpotBugs for accurate Java static analysis, sharing installation links, usage notes, and scan results.

IntelliJSpotBugsStatic Analysis
0 likes · 6 min read
Using SpotBugs and IntelliJ Plugins for Java Static Code Analysis
ITPUB
ITPUB
Nov 2, 2020 · Backend Development

When Lombok’s Magic Turns Toxic: Hidden Risks of Java Boilerplate Reduction

The article examines Lombok’s ability to shrink Java boilerplate with annotations, walks through code before and after its use, and highlights five major drawbacks—including JDK incompatibility, forced plugin dependence, reduced readability, tighter coupling, and technical debt—suggesting careful team evaluation before adoption.

Lombokannotationsboilerplate
0 likes · 10 min read
When Lombok’s Magic Turns Toxic: Hidden Risks of Java Boilerplate Reduction
Programmer DD
Programmer DD
Nov 2, 2020 · Fundamentals

How to Evaluate Code Quality: Standards and Metrics for Clean, Maintainable Code

This article explains practical code quality evaluation standards—coding conventions, readability, maintainability, duplication, and testability—and introduces the five dimensions used by Iceworks Doctor to score projects, helping teams adopt consistent, high‑quality coding practices.

Software Engineeringcode qualitycoding standards
0 likes · 6 min read
How to Evaluate Code Quality: Standards and Metrics for Clean, Maintainable Code
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Oct 13, 2020 · Fundamentals

Mastering Software Roles, Refactoring, and Quality: A 20‑Year Engineer’s Guide

This article explores how software engineers can improve their work by clearly defining roles, applying systematic refactoring strategies, and enforcing quality through team consensus, testing practices, and a strong engineering culture, drawing on over two decades of industry experience.

Software Engineeringcode qualitydeveloper culture
0 likes · 13 min read
Mastering Software Roles, Refactoring, and Quality: A 20‑Year Engineer’s Guide
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 27, 2020 · R&D Management

Tackling Code Quality, Testing, and Efficiency Challenges in Software Development

This article examines common pitfalls in code quality, testing, and development efficiency, analyzes their root causes, and proposes concrete, actionable solutions such as performance optimization, stricter coding standards, regular code reviews, improved testing practices, and enhanced team collaboration to boost overall software project success.

R&D ManagementSoftware testingcode quality
0 likes · 12 min read
Tackling Code Quality, Testing, and Efficiency Challenges in Software Development
Python Crawling & Data Mining
Python Crawling & Data Mining
Sep 3, 2020 · Fundamentals

Boost Your Python Code Quality with Type Annotations

This article introduces Python type annotations, explains why they improve code consistency and readability in collaborative projects, demonstrates simple and advanced usage with code examples and screenshots, and encourages developers to adopt static typing for better maintenance and fewer runtime errors.

best practicescode qualityprogramming
0 likes · 5 min read
Boost Your Python Code Quality with Type Annotations
Liangxu Linux
Liangxu Linux
Aug 29, 2020 · Fundamentals

Why a Two‑Line Fix Can Take Two Days: Hidden Costs of Bug Fixing

A seemingly simple two‑line code change can stretch into days because of unclear bug reports, unfamiliar features, thorough root‑cause analysis, multiple reproduction paths, impact checks, careful solution design, and comprehensive testing, all of which aim to prevent future regressions.

Bug fixingSoftware Engineeringcode quality
0 likes · 5 min read
Why a Two‑Line Fix Can Take Two Days: Hidden Costs of Bug Fixing
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 23, 2020 · Fundamentals

Why Large Software Systems Spiral into Complexity and How to Tame It

This article explores why massive distributed applications quickly become complex, identifies cognitive load and collaboration cost as the two main dimensions of software complexity, and offers practical design, naming, testing, and documentation strategies to keep systems maintainable over time.

Cognitive LoadDesign PrinciplesMicroservices
0 likes · 25 min read
Why Large Software Systems Spiral into Complexity and How to Tame It
ITPUB
ITPUB
Aug 18, 2020 · Fundamentals

How to Write Clear Git Commit Messages and Enforce Them with Webhooks

This article explains why clear Git commit messages matter, presents a concrete commit‑message format with type, optional scope, and subject, lists the allowed types, shows examples, and describes a webhook‑based monitoring service that warns or blocks non‑conforming commits while also tracking large changes and file deletions.

Commit Messagecode qualityconvention
0 likes · 10 min read
How to Write Clear Git Commit Messages and Enforce Them with Webhooks
Java Captain
Java Captain
Aug 16, 2020 · Fundamentals

Why Classes Should Not Be Too Long and How to Refactor Overgrown Classes

The article explains why excessively long classes with many responsibilities hinder readability and extensibility, outlines the problems of redundant code and SRP violations, and provides practical refactoring techniques—such as extracting methods, moving members, and creating new classes—using IntelliJ IDEA.

IntelliJ IDEASingle Responsibility PrincipleSoftware Design
0 likes · 11 min read
Why Classes Should Not Be Too Long and How to Refactor Overgrown Classes
Youku Technology
Youku Technology
Aug 3, 2020 · Fundamentals

Mastering Defensive Programming: Guard Clauses, Exceptions, and DRY in Java

This article explains how to write robust Java code by applying defensive programming techniques such as guard clauses, proper exception handling, validator usage, assertions, and the DRY principle, while illustrating each concept with clear code examples and practical guidelines.

DRY principleException Handlingcode quality
0 likes · 20 min read
Mastering Defensive Programming: Guard Clauses, Exceptions, and DRY in Java
QQ Music Frontend Team
QQ Music Frontend Team
Jul 20, 2020 · Fundamentals

Why Refactoring Matters: Principles, Timing, and Practical Techniques

Refactoring improves code understandability and reduces maintenance costs by reorganizing internal structure without changing behavior, and this guide explains its purpose, timing, principles, common code smells, measurement metrics, and practical techniques across data, statement, subroutine, class, and system levels.

Software Designbest practicescode quality
0 likes · 20 min read
Why Refactoring Matters: Principles, Timing, and Practical Techniques
Youku Technology
Youku Technology
Jul 17, 2020 · Backend Development

Defensive Programming, Exception Handling, and DRY Principle in Java

The article explains how defensive programming in Java—using guard clauses, validators, and side‑effect‑free assertions—prevents errors, outlines proper exception handling by distinguishing checked from unchecked exceptions, and reinforces the DRY principle, urging developers to abstract repeated logic after three occurrences.

DRY principleException HandlingSoftware Engineering
0 likes · 18 min read
Defensive Programming, Exception Handling, and DRY Principle in Java
政采云技术
政采云技术
Jul 12, 2020 · Frontend Development

Developing Custom ESLint Rules for Consistent and Maintainable Frontend Code

This comprehensive guide explores the principles of ESLint and abstract syntax trees, providing step-by-step instructions for developing custom linting rules and plugins to enforce coding standards, prevent hardcoded configurations, and maintain high-quality frontend codebases across collaborative development environments.

AST ParsingCustom Linting RulesESLint
0 likes · 10 min read
Developing Custom ESLint Rules for Consistent and Maintainable Frontend Code
NetEase Game Operations Platform
NetEase Game Operations Platform
Jul 11, 2020 · Operations

GitLab Code Review Workflow and Configuration Guide

This article provides a comprehensive guide to GitLab code review, covering environment setup, Git flow basics, review methods, configuration of approvals, templates, issue linking, Code Quality integration with CI/CD, step‑by‑step practice, and recommendations for choosing between Community and Enterprise editions.

CI/CDDevOpsGitLab
0 likes · 10 min read
GitLab Code Review Workflow and Configuration Guide
Qunhe Technology Quality Tech
Qunhe Technology Quality Tech
Jun 5, 2020 · R&D Management

How a Unified Code Metrics Platform Boosts Development Quality and Efficiency

This article describes the design, implementation, and operational strategy of a comprehensive code‑metrics platform that standardizes coding standards, automates quality checks, and drives data‑guided improvements across multiple development teams, ultimately enhancing code reliability, maintainability, and CI/CD flow.

CI/CDQuality AssuranceR&D Management
0 likes · 10 min read
How a Unified Code Metrics Platform Boosts Development Quality and Efficiency
Java Captain
Java Captain
May 30, 2020 · Fundamentals

Integrating SonarLint into IntelliJ IDEA for Pre‑Commit Code Quality Checks

This guide explains how to integrate SonarLint into IntelliJ IDEA to perform pre‑commit code quality checks, covering the tool’s objectives, the seven quality dimensions it assesses, required prerequisites, plugin installation steps, and detailed project and server configuration procedures.

IntelliJ IDEAcode qualityjava
0 likes · 4 min read
Integrating SonarLint into IntelliJ IDEA for Pre‑Commit Code Quality Checks
Top Architect
Top Architect
May 20, 2020 · Fundamentals

Eliminating Overused if…else Statements: Refactoring Techniques and Design Patterns

This article examines why excessive if…else statements harm code readability and maintainability, and presents a range of refactoring approaches—including table‑driven mapping, chain‑of‑responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism—to replace or simplify them, while also addressing deep nesting and complex conditional expressions.

Design PatternsSoftware Engineeringcode quality
0 likes · 19 min read
Eliminating Overused if…else Statements: Refactoring Techniques and Design Patterns
Continuous Delivery 2.0
Continuous Delivery 2.0
May 13, 2020 · Backend Development

Practical Guide to Unit Testing: Experiences, Benefits, Obstacles, and Implementation Strategies

This comprehensive article shares the author's hands‑on experience with unit testing, explains why testing drives better design and lower costs, outlines common misconceptions and obstacles, and provides detailed implementation guidelines—including architecture refactoring, dependency inversion, and a real‑world TV service example—to help developers start writing effective unit tests.

code qualitysoftware architecturetesting practices
0 likes · 26 min read
Practical Guide to Unit Testing: Experiences, Benefits, Obstacles, and Implementation Strategies
21CTO
21CTO
May 12, 2020 · Fundamentals

Avoid These Common Programming Mistakes to Boost Code Quality

This article outlines frequent programming errors—such as trusting user input, skipping tests, neglecting documentation and logs, hard‑coding values, ignoring rest, and failing to keep learning—and offers practical advice to prevent them and improve software reliability.

Documentationcode qualityprogramming best practices
0 likes · 5 min read
Avoid These Common Programming Mistakes to Boost Code Quality
Architecture Digest
Architecture Digest
May 7, 2020 · Fundamentals

Eliminating Excessive if…else: Patterns and Refactoring Techniques

This article examines the problems caused by overusing if…else statements in code—such as poor readability, maintainability, and violation of design principles—and presents a collection of refactoring patterns, including table‑driven design, chain of responsibility, annotation‑driven, event‑driven, state machines, Optional, guard clauses, and polymorphism, with concrete Java examples.

Design PatternsSoftware Engineeringcode quality
0 likes · 19 min read
Eliminating Excessive if…else: Patterns and Refactoring Techniques
DevOps
DevOps
May 6, 2020 · Fundamentals

The Elephant in the Room: Reflections on Bad Code, Industry Myths, and How to Improve Software Development

In this translated talk, Niclas Hedhman examines why poor code proliferates in the software industry, debunks common myths about development, highlights the hidden challenges programmers face, and proposes practical principles such as the KISS rule to gradually raise code quality and developer satisfaction.

Software Engineeringcode qualityindustry myths
0 likes · 13 min read
The Elephant in the Room: Reflections on Bad Code, Industry Myths, and How to Improve Software Development