BestHub
Sign in
Tagged articles
517 articles
Page 4 of 6
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.

IDEASoftware Engineeringclass design
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
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 PatternsSoftware Architecturecode quality
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 IDEAJava
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.

Domain-Driven DesignSoftware Architecturecode 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.

Cache StrategyDatabase Optimizationbug reduction
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 OptimizationSoftware Architecturecode quality
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.

DSLRustTree-sitter
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.

code qualityfrontendlegacy systems
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.

SOLIDcode qualitydesign principles
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.

code qualityincident managementrelease 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.

JavaSonarQubecode quality
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 principlesSoftware Architecture
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.

JDKJavacode 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 PatternsPythonSoftware Architecture
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-JSJavaScript
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 EngineeringVersion Controlcode quality
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 reviewGolangSoftware 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 reviewSoftware qualityTechnical Debt
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.

AutomationDevOpsJenkins
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.

JavaSoftware Engineeringbest practices
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.

DockerJetBrainsci/cd
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.

Software Engineeringclean codecode quality
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.

DevOpsSASTSecurity
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.

Software EngineeringTool Selectionci/cd
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.

JavaSoftware Engineeringbest practices
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 EngineeringTechnical Debtbest practices
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.

IntelliJJavaSpotBugs
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.

BoilerplateJavaLombok
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.

Performance OptimizationR&D managementSoftware Testing
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.

Software Engineeringbug fixingcode 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.

MicroservicesSoftware Architecturecode quality
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.

code qualitycommit messageconvention
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 IDEAclass designcode quality
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 HandlingJava
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.

best practicescode qualityrefactoring
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 HandlingJava
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/CDDevOpsGit Flow
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.

R&D managementci/cdcode quality
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 IDEAJavacode quality
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.

Software Architecturecode qualitytesting 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
Programmer DD
Programmer DD
May 5, 2020 · Fundamentals

Why Long Classes Break Your Code and How to Refactor Them with IDEA

This article explains why excessively long classes are hard to read and extend, outlines the problems caused by redundant code and multiple responsibilities, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and create new classes.

IDEAJavacode quality
0 likes · 8 min read
Why Long Classes Break Your Code and How to Refactor Them with IDEA
Java Backend Technology
Java Backend Technology
May 5, 2020 · Fundamentals

Why Your 900-Line Class Is a Nightmare and How to Refactor It

The article explains why excessively long classes are hard to read, extend, and maintain, outlines the problems caused by redundant code and multiple responsibilities, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and create new classes.

IDEOOPcode quality
0 likes · 8 min read
Why Your 900-Line Class Is a Nightmare and How to Refactor It
Top Architect
Top Architect
Apr 29, 2020 · Fundamentals

Eliminating Excessive if...else Statements: Problems, Solutions, and Refactoring Techniques

The article examines the drawbacks of overusing if...else constructs in software, explains why they harm readability and maintainability, and presents ten practical refactoring methods—including table‑driven, chain‑of‑responsibility, annotation‑driven, event‑driven, state machine, Optional, Assert, guard clauses, and method extraction—to simplify or replace complex conditional logic.

Design PatternsSoftware Engineeringcode quality
0 likes · 16 min read
Eliminating Excessive if...else Statements: Problems, Solutions, and Refactoring Techniques
DevOps Cloud Academy
DevOps Cloud Academy
Apr 21, 2020 · Operations

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

This article discusses common challenges encountered when using SonarQube at scale—including data instability across branches, rule configuration for new projects, and project permission management—and presents practical solutions such as branch-specific project naming, Jenkins-driven API automation, and recommendations for purchasing commercial editions.

AutomationDevOpsJenkins
0 likes · 6 min read
Resolving Common SonarQube Issues: Data Instability, Rule Configuration, and Project Authorization
21CTO
21CTO
Apr 17, 2020 · Fundamentals

10 Proven Techniques to Eliminate Excessive if…else in Your Code

This article explains why overusing if…else harms code readability and maintainability, outlines ten practical methods—including table‑driven, chain of responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism—to refactor or replace complex conditional logic, and provides Java code examples for each approach.

Design PatternsSoftware Engineeringcode quality
0 likes · 16 min read
10 Proven Techniques to Eliminate Excessive if…else in Your Code
dbaplus Community
dbaplus Community
Apr 16, 2020 · Fundamentals

Why Code Quality Fails Projects and 4 Proven Ways to Fix It

The article examines why many software projects deteriorate due to poor code quality, outlines four common pitfalls such as oversized components, low cohesion, tangled logic, and rampant if‑else statements, and presents concrete refactoring strategies—including inverted‑pyramid design, lib/framework separation, Template Method pattern, and rich enums—to dramatically improve maintainability and project success.

Design PatternsSoftware Engineeringcode quality
0 likes · 37 min read
Why Code Quality Fails Projects and 4 Proven Ways to Fix It
macrozheng
macrozheng
Apr 14, 2020 · Fundamentals

Why Code Quality Matters: 4 Common Pitfalls and Proven Solutions for Developers

This article examines why high‑quality, maintainable code is essential for software projects, outlines four recurring code‑quality problems—including oversized components, low cohesion, tangled logic, and excessive if‑else—and presents concrete refactoring patterns such as inverted‑pyramid design, proper lib/framework reuse, Template Method separation, and rich enum types, while also introducing a CODEX indexing technique for large codebases.

Design PatternsSoftware Architecturebest practices
0 likes · 38 min read
Why Code Quality Matters: 4 Common Pitfalls and Proven Solutions for Developers
HomeTech
HomeTech
Apr 1, 2020 · Fundamentals

Static Code Scanning: Principles, Tools, and Three Years of Practice in a Dealer Technology Department

This article explains the fundamentals of static code scanning, reviews popular analysis tools such as Checkstyle, FindBugs, PMD and SonarQube, and details a three‑year evolution of a dealer technology department’s CI/CD integration, automation, metrics, and key success factors for effective code quality assurance.

JenkinsSoftware EngineeringSonarQube
0 likes · 10 min read
Static Code Scanning: Principles, Tools, and Three Years of Practice in a Dealer Technology Department
Programmer DD
Programmer DD
Mar 24, 2020 · Fundamentals

How to Write Code Nobody Can Maintain – A Satirical Guide

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

JavaSoftware Engineeringbad practices
0 likes · 12 min read
How to Write Code Nobody Can Maintain – A Satirical Guide
Programmer DD
Programmer DD
Mar 9, 2020 · Fundamentals

19 Hilarious Rules for Writing the Worst Code (And How to Avoid Them)

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

Software Engineeringbad practicescode quality
0 likes · 8 min read
19 Hilarious Rules for Writing the Worst Code (And How to Avoid Them)
ITPUB
ITPUB
Feb 9, 2020 · Fundamentals

19 Counterintuitive Rules for Writing Deliberately Bad Code

This article presents a tongue‑in‑cheek guide of nineteen "anti‑best‑practice" rules sourced from a GitHub project, illustrating how to deliberately produce unreadable, unmaintainable code by minimizing typing, mixing naming styles, avoiding comments, and other absurd conventions.

Anti-PatternsGitHubSoftware Engineering
0 likes · 6 min read
19 Counterintuitive Rules for Writing Deliberately Bad Code
Architecture Digest
Architecture Digest
Feb 6, 2020 · Backend Development

Refactoring a 3000‑Line C# System to 15 Lines: Lessons and Practices

An experienced developer recounts how he transformed a cumbersome three‑tier C# data‑center management system from thousands of lines to a concise, maintainable codebase using reflection, generics, and thoughtful refactoring, while sharing practical advice on avoiding code generators, reducing duplication, and embracing unit testing.

Backend DevelopmentCDesign Patterns
0 likes · 18 min read
Refactoring a 3000‑Line C# System to 15 Lines: Lessons and Practices
Liangxu Linux
Liangxu Linux
Jan 30, 2020 · Information Security

Top 11 Open-Source Code Quality and Security Tools Every Developer Should Know

An overview of eleven essential open-source and commercial tools—including SonarQube, Kritika, DeepScan, Klocwork, CodeSonar, JArchitect, Bandit, Code Climate, Crucible, Fortify, and Codecov—that help developers analyze code quality, detect security vulnerabilities, and integrate seamlessly into CI/CD pipelines across multiple programming languages.

ci/cdcode qualityopen-source tools
0 likes · 8 min read
Top 11 Open-Source Code Quality and Security Tools Every Developer Should Know
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 19, 2020 · Fundamentals

How to Identify, Break, and Prevent Technical Debt in Software Projects

The article explains what technical debt is, how it creates a vicious cycle that slows development, outlines common causes such as rushed releases and copy‑paste coding, and offers practical strategies—including measurement tools, incremental migration and full rewrites—to manage and avoid it.

Project ManagementSoftware EngineeringTechnical Debt
0 likes · 9 min read
How to Identify, Break, and Prevent Technical Debt in Software Projects
FunTester
FunTester
Jan 7, 2020 · Fundamentals

Why High Test Coverage Can Mislead You: Lessons from Java Code

This article explains how test‑coverage metrics such as line and branch coverage can give a false sense of quality, demonstrates common pitfalls with Java examples and Cobertura reports, and offers practical guidelines for using coverage data to improve testing and code reliability.

CoberturaJUnitJava
0 likes · 17 min read
Why High Test Coverage Can Mislead You: Lessons from Java Code
21CTO
21CTO
Jan 3, 2020 · Fundamentals

12 Warning Signs That Your Software Design Is Growing Too Complex

The article lists twelve danger signals—ranging from shallow modules and information leaks to vague naming and unreadable code—that reveal hidden complexity in software design and help developers identify and refactor problematic patterns.

Anti-Patternscode qualitycomplexity
0 likes · 6 min read
12 Warning Signs That Your Software Design Is Growing Too Complex
ITPUB
ITPUB
Nov 26, 2019 · Fundamentals

Linus Torvalds on Open Source, Coding Philosophy, and Elegant Linked‑List Removal

In a candid interview, Linus Torvalds shares his pragmatic engineering mindset, explains why Git was his second major project, and demonstrates how a clean pointer‑indirection technique can simplify linked‑list element removal, contrasting it with a more cumbersome approach.

Linus TorvaldsSoftware Engineeringcode quality
0 likes · 6 min read
Linus Torvalds on Open Source, Coding Philosophy, and Elegant Linked‑List Removal
FunTester
FunTester
Nov 21, 2019 · Operations

How to Build a Robust SaaS Testing Strategy to Cut Costs and Boost Quality

Effective software testing is essential for SaaS startups to avoid costly failures; this guide outlines five key strategies—aligning quality checks with business goals, detailed test planning, fostering a supportive testing environment, conducting user acceptance testing, and measuring code quality with CISQ metrics—to ensure high‑quality releases.

CISQProduct DevelopmentSaaS
0 likes · 7 min read
How to Build a Robust SaaS Testing Strategy to Cut Costs and Boost Quality
Senior Brother's Insights
Senior Brother's Insights
Nov 13, 2019 · Operations

Mastering System Performance: Principles, Layers, and Practical Optimization Techniques

This article outlines fundamental performance‑optimization principles, the hierarchical stages of optimization (requirements, design, implementation), and practical methods such as caching, concurrency, laziness, batching, efficient implementations, and solution‑space reduction, while stressing the balance with code quality and long‑term maintenance.

ProfilingSystemscaching
0 likes · 13 min read
Mastering System Performance: Principles, Layers, and Practical Optimization Techniques