BestHub
Sign in
Tagged articles
389 articles
Page 3 of 4
Python Programming Learning Circle
Python Programming Learning Circle
Mar 11, 2022 · Fundamentals

Refactoring a Python Employee Management System to Eliminate Code Smells

This article explains common Python code smells in an employee‑management example, demonstrates why practices such as using raw strings for roles, duplicated search methods, excessive isinstance checks, and vague boolean flags are problematic, and provides a step‑by‑step refactor using Enums, abstract base classes, list comprehensions, custom exceptions, and clearer method separation.

Abstract Base ClassDesign PatternsPython
0 likes · 14 min read
Refactoring a Python Employee Management System to Eliminate Code Smells
21CTO
21CTO
Mar 7, 2022 · Fundamentals

10 Must‑Have JetBrains IDE Extensions to Tackle Technical Debt

Discover ten JetBrains IDE extensions that help developers reduce technical debt by improving code refactoring, issue tracking, static analysis, security scanning, and overall code quality across Java, Kotlin, and many other languages.

IDE ExtensionsJetBrainsRefactoring
0 likes · 7 min read
10 Must‑Have JetBrains IDE Extensions to Tackle Technical Debt
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.

JavaRefactoringcode quality
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.

Best PracticesJavaRefactoring
0 likes · 38 min read
20 Code Smells That Drive Developers Crazy (And How to Fix Them)
Code Ape Tech Column
Code Ape Tech Column
Feb 8, 2022 · Backend Development

Refactoring Long if...else Chains in Java Using Design Patterns and Spring

This article explains why lengthy if...else statements in Java payment services violate the Open‑Closed and Single‑Responsibility principles and demonstrates several refactoring techniques—including annotations, dynamic bean naming, template methods, strategy‑factory, and chain‑of‑responsibility patterns—using Spring to eliminate the conditional logic.

Design PatternsJavaRefactoring
0 likes · 15 min read
Refactoring Long if...else Chains in Java Using Design Patterns and Spring
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Jan 27, 2022 · Frontend Development

Top 10 Must-Read Front-End Articles to Boost Your Skills

This roundup highlights ten essential front‑end articles covering performance metrics, refactoring principles, React Hooks, Markdown, modularization, H5 optimization, mini‑programs, async/await debates, Nohost open‑source insights, and Remix pre‑loading techniques, offering valuable knowledge for developers.

FrontendMarkdownPerformance
0 likes · 4 min read
Top 10 Must-Read Front-End Articles to Boost Your Skills
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 DesignPerformanceRefactoring
0 likes · 20 min read
Write Maintainable, High‑Performance Backend Code: Standards, Design Patterns & Optimization Tips
Tencent Cloud Developer
Tencent Cloud Developer
Jan 12, 2022 · Frontend Development

How to Write Readable JavaScript Code: Tips for Clean, Maintainable Code

The article explains why readable code matters, shows a messy JavaScript example, lists common readability problems, and provides concrete guidelines—consistent style, meaningful naming, proper comments, small files, shallow nesting—along with tooling tips such as ESLint, Standard Style, husky and lint‑staged to enforce them.

ESLintJavaScriptRefactoring
0 likes · 10 min read
How to Write Readable JavaScript Code: Tips for Clean, Maintainable Code
Alibaba Terminal Technology
Alibaba Terminal Technology
Dec 27, 2021 · Fundamentals

Why Good Naming Is the Secret Weapon for Clean Code

Effective naming in software development, illustrated with real code examples and visual metaphors, transforms ambiguous code into clear, self‑documenting logic, improves readability, reduces errors, and aligns with best practices such as modeling, meaningful differentiation, and consistent style, ultimately enhancing maintainability.

Best PracticesRefactoringcode readability
0 likes · 17 min read
Why Good Naming Is the Secret Weapon for Clean Code
Programmer DD
Programmer DD
Dec 2, 2021 · Backend Development

Explore IntelliJ IDEA 2021.3: Remote Development, Smart Refactoring, and New Spring Support

IntelliJ IDEA 2021.3 introduces a beta remote development mode, enhanced IDE repair tools, convenient font scaling, streamlined Markdown table creation, advanced unsafe string checks, improved refactoring shortcuts, and multiple Spring framework enhancements, all illustrated with screenshots and GIFs for developers.

IDE FeaturesIntelliJ IDEAJava
0 likes · 6 min read
Explore IntelliJ IDEA 2021.3: Remote Development, Smart Refactoring, and New Spring Support
JavaEdge
JavaEdge
Nov 28, 2021 · Fundamentals

How to Spot and Eliminate Hidden Duplicate Code in Your Projects

The article explains why copy‑pasting code (CV) creates maintenance nightmares, shows how to identify structural and conditional duplication, and provides concrete refactoring steps—extracting methods, using common interfaces, and applying functional techniques—to achieve DRY and improve code readability.

DRYRefactoringcode duplication
0 likes · 8 min read
How to Spot and Eliminate Hidden Duplicate Code in Your Projects
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.

FrontendJavaScriptPromise
0 likes · 11 min read
Refactoring Examples for Common Business Scenarios: From Callback Hell to Promise.all and Pure Functions
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Nov 15, 2021 · Frontend Development

How IMFLOW Was Re‑Engineered: From Monolithic Tool to Modular Build‑Kit Architecture

This article explains the complete redesign of IMFLOW, a Webpack‑based engineering tool, detailing the motivations, goals, refactoring patterns, modular architecture, plugin system, and performance improvements that transformed it from a heavyweight monolith into a lightweight, extensible core‑plus‑build‑kit solution for frontend development.

Build ToolFrontendRefactoring
0 likes · 37 min read
How IMFLOW Was Re‑Engineered: From Monolithic Tool to Modular Build‑Kit Architecture
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 29, 2021 · Fundamentals

25 Common Code Smells and Their Refactoring Solutions

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

Refactoringclean codecode smells
0 likes · 17 min read
25 Common Code Smells and Their Refactoring Solutions
Python Programming Learning Circle
Python Programming Learning Circle
Oct 15, 2021 · Fundamentals

Improving Code Quality with SOLID Principles, Architecture Patterns, and Refactoring Techniques

This article explains how applying the five SOLID principles, choosing appropriate system architectures, using clear naming, drawing diagrams, and refactoring code—including guard clauses, responsibility‑chain patterns, and composition over inheritance—can dramatically improve Python program design and maintainability.

PythonRefactoringSOLID
0 likes · 21 min read
Improving Code Quality with SOLID Principles, Architecture Patterns, and Refactoring Techniques
MaGe Linux Operations
MaGe Linux Operations
Oct 5, 2021 · Fundamentals

11 Essential PyCharm Tips to Supercharge Your Python Workflow

This guide presents eleven practical PyCharm tricks—from adjusting font sizes and customizing the UI to efficient code commenting, refactoring, package management, and debugging—helping both beginners and seasoned developers boost productivity and master the IDE’s powerful features.

DebuggingIDEPython
0 likes · 8 min read
11 Essential PyCharm Tips to Supercharge Your Python Workflow
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.

IDEARefactoringcode quality
0 likes · 9 min read
Why Long Classes Are Problematic and How to Refactor Them
JD Tech
JD Tech
Sep 18, 2021 · Fundamentals

The Importance of Unit Testing, Test Models, TDD, and Refactoring

This article explains why testing—especially unit testing—is essential, compares the "egg‑roll" and "test pyramid" models, introduces test‑driven and test‑first development, discusses simple testing practices, and outlines refactoring principles and quality guidelines for developers.

RefactoringSoftware qualityTest‑Driven Development
0 likes · 11 min read
The Importance of Unit Testing, Test Models, TDD, and Refactoring
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.

IDEARefactoringclass design
0 likes · 8 min read
Why You Should Avoid Writing Thousand‑Line Classes and How to Refactor Them
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Aug 20, 2021 · Frontend Development

Evolution of a New Web Live Streaming System: From Flash to HTML5, AI Integration, and Modular Refactoring

This article chronicles the development of a new web live streaming solution, detailing the shift from Flash to HTML5 video, the integration of AI voice detection using hark, audio encoding with lamejs, WebRTC-based real‑time communication, and a systematic modular refactor that transformed the project into a reusable frontend framework.

FrontendHTML5JavaScript
0 likes · 8 min read
Evolution of a New Web Live Streaming System: From Flash to HTML5, AI Integration, and Modular Refactoring
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 16, 2021 · Fundamentals

Why Refactoring Matters: Practical Tips and Code Smell Solutions

This article, based on the author’s experience and Martin Fowler’s book, explains what refactoring is, why it’s essential, how to spot code smells, and provides concrete principles and JavaScript examples to improve code design, readability, and maintainability without focusing on performance.

Best PracticesJavaScriptRefactoring
0 likes · 27 min read
Why Refactoring Matters: Practical Tips and Code Smell Solutions
JD Retail Technology
JD Retail Technology
Aug 16, 2021 · Backend Development

Refactoring a Complex Backend System: Decoupling Logic, Dynamic Configuration, and Result Isolation

This article shares practical refactoring techniques applied to JD App's backend, demonstrating how to decouple tightly‑coupled modules, replace hard‑coded logic with dynamic configuration, and isolate result fields to improve maintainability and extensibility in large‑scale backend projects.

Dynamic ConfigurationRefactoringmodularization
0 likes · 11 min read
Refactoring a Complex Backend System: Decoupling Logic, Dynamic Configuration, and Result Isolation
IT Architects Alliance
IT Architects Alliance
Aug 11, 2021 · Backend Development

Insights from Leading Architects on System Refactoring, Platform Evolution, and High‑Performance Architecture

The article compiles expert experiences from major Chinese tech firms on progressive system refactoring, platform‑centric redesign, service‑oriented evolution, and high‑performance architecture, highlighting practical steps, technology choices, and lessons learned for modern backend and operations engineering.

Cloud NativeMicroservicesRefactoring
0 likes · 13 min read
Insights from Leading Architects on System Refactoring, Platform Evolution, and High‑Performance Architecture
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 PatternsRefactoringSoftware Architecture
0 likes · 38 min read
Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes
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 DesignRefactoring
0 likes · 21 min read
Preventing Software Degradation with Domain‑Driven Design and the Two‑Hat Refactoring Approach
Wukong Talks Architecture
Wukong Talks Architecture
Jul 12, 2021 · Fundamentals

25 Common Code Smells and Refactoring Techniques

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

Refactoringbad practiceclean code
0 likes · 23 min read
25 Common Code Smells and Refactoring Techniques
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 9, 2021 · Fundamentals

Evolution of Software Development, OOP, and Functional Refactoring with Java Predicates

The article traces the three historical stages of software development, explains object‑oriented programming fundamentals, highlights the duplication problem in traditional query methods, and demonstrates how Java 8 functional programming with Predicate interfaces can refactor and compose flexible query logic.

Functional ProgrammingJavaPredicates
0 likes · 7 min read
Evolution of Software Development, OOP, and Functional Refactoring with Java Predicates
ELab Team
ELab Team
Jul 8, 2021 · Frontend Development

How Clean Code Practices Supercharge Your JavaScript Projects

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

Best PracticesRefactoringclean code
0 likes · 15 min read
How Clean Code Practices Supercharge Your JavaScript Projects
IT Architects Alliance
IT Architects Alliance
Jul 4, 2021 · Industry Insights

Why Do Software Architectures Decay Over Time and How to Prevent It?

The article examines why software architectures inevitably degrade as projects grow, outlines the stages of decay, critiques common quick fixes, and proposes strategic solutions such as adopting new technologies, refactoring into isolated components, using separate processes, and building loosely coupled platforms to sustain long‑term maintainability.

Build OptimizationRefactoringSoftware Architecture
0 likes · 25 min read
Why Do Software Architectures Decay Over Time and How to Prevent It?
KooFE Frontend Team
KooFE Frontend Team
Jun 14, 2021 · Fundamentals

How to Write Clean, Readable JavaScript Code: Essential Practices

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

RefactoringTeam CollaborationTechnical debt
0 likes · 11 min read
How to Write Clean, Readable JavaScript Code: Essential Practices
Liangxu Linux
Liangxu Linux
Jun 8, 2021 · Fundamentals

Boost Your IntelliJ IDEA Efficiency with Hidden Keyboard Shortcuts

Learn essential IntelliJ IDEA shortcuts—including navigation, history view, auto-completion, variable extraction, renaming, and a serialVersionUID generator plugin—to streamline coding, reduce mouse clicks, and boost productivity across Windows and macOS environments for Java development.

Code navigationIntelliJ IDEARefactoring
0 likes · 5 min read
Boost Your IntelliJ IDEA Efficiency with Hidden Keyboard Shortcuts
Top Architect
Top Architect
Jun 4, 2021 · Backend Development

Design and Refactoring of a Rule Engine for User Application Processing

This article describes the design, short‑circuit execution logic, and refactoring of a backend rule engine that evaluates user application criteria using AND/OR relationships, outlines its implementation steps, and discusses its advantages and drawbacks for maintainability.

RefactoringRule Engineshort-circuit logic
0 likes · 4 min read
Design and Refactoring of a Rule Engine for User Application Processing
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.

RefactoringSOLIDcode quality
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 PatternsRefactoringSOLID
0 likes · 36 min read
Why Refactoring Matters: Transform Bad Code into Clean, Maintainable Software
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 29, 2021 · Fundamentals

Understanding the Strategy Design Pattern in Java

This article introduces the Strategy design pattern, explains its definition, class diagram, Java implementation examples, advantages and disadvantages, and demonstrates its use in JDK components such as Comparator and ThreadPoolExecutor, helping developers replace complex if‑else logic with interchangeable algorithm objects.

Design PatternsJavaRefactoring
0 likes · 10 min read
Understanding the Strategy Design Pattern in Java
21CTO
21CTO
Apr 1, 2021 · Backend Development

When and How to Refactor Legacy Systems into Microservices

This article explains the signs that indicate a legacy system needs refactoring, describes the challenges of a monolithic architecture with massive tables, outlines goals such as zero business impact and migration to microservices, and details a step‑by‑step migration strategy using data pipelines and careful interface compatibility.

Data MigrationMicroservicesRefactoring
0 likes · 8 min read
When and How to Refactor Legacy Systems into Microservices
Sohu Tech Products
Sohu Tech Products
Mar 10, 2021 · Frontend Development

Applying jscodeshift Codemods for Large‑Scale Frontend Refactoring

This article explains how to use codemod tools, especially jscodeshift, to automatically refactor a growing frontend codebase by replacing a monolithic constants package with per‑constant imports, covering the underlying AST concepts, step‑by‑step script creation, and practical CLI usage.

ASTFrontendRefactoring
0 likes · 11 min read
Applying jscodeshift Codemods for Large‑Scale Frontend Refactoring
ByteFE
ByteFE
Mar 2, 2021 · Frontend Development

Using jscodeshift Codemod to Refactor Large‑Scale Frontend Projects

This article explains how to create and run a jscodeshift codemod that transforms imports of a bulky constants package into per‑constant imports, reducing bundle size in large frontend codebases by leveraging AST parsing, AST Explorer, and automated code modifications.

ASTRefactoringcodemod
0 likes · 16 min read
Using jscodeshift Codemod to Refactor Large‑Scale Frontend Projects
Laravel Tech Community
Laravel Tech Community
Feb 21, 2021 · Frontend Development

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

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

AsyncFrontendJavaScript
0 likes · 10 min read
Refactoring Examples for Dependent Requests and Complex If‑Else Logic in JavaScript
Liangxu Linux
Liangxu Linux
Feb 19, 2021 · Fundamentals

Mastering Code Smells: Identify and Refactor Common Bad Practices

This guide explains the most frequent code smells—Long Method, Large Class, Duplicated Code, Long Parameter List, Shotgun Surgery, Speculative Generality, and excessive comments—detailing why they harm readability and maintainability, and provides concrete refactoring techniques with Java examples to produce cleaner, more modular software.

Best PracticesJavaRefactoring
0 likes · 14 min read
Mastering Code Smells: Identify and Refactor Common Bad Practices
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.

Best PracticesPHPRefactoring
0 likes · 9 min read
Practical Refactoring Tips for Cleaner PHP Code
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.

Best PracticesJavaRefactoring
0 likes · 14 min read
10 Practical Java Refactoring Techniques Every Developer Should Master
dbaplus Community
dbaplus Community
Jan 9, 2021 · Backend Development

How We Refactored a 30k‑Line Ad Engine in One Month: Key Lessons

In this detailed case study, a team describes how they successfully refactored a 30,000‑line advertising engine within a month, covering the system's legacy challenges, preparation steps, execution tactics, testing strategies, and the seven critical takeaways that ensured a smooth, low‑risk rollout.

Ad TechProject ManagementRefactoring
0 likes · 11 min read
How We Refactored a 30k‑Line Ad Engine in One Month: Key Lessons
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 4, 2021 · Fundamentals

How TDD and GTest Transform Legacy Navigation Systems: A Practical Guide

This article explores how Test‑Driven Development and Google Test can improve quality and enable incremental refactoring of a complex, legacy online navigation system by addressing the shortcomings of traditional diff‑based testing, introducing unit‑testing fundamentals, and sharing practical implementation details and lessons learned.

CRefactoringTDD
0 likes · 10 min read
How TDD and GTest Transform Legacy Navigation Systems: A Practical Guide
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.

Refactoringclean codecode quality
0 likes · 13 min read
How to Spot and Eliminate Common Code Smells for Cleaner, More Maintainable Code
IT Xianyu
IT Xianyu
Dec 23, 2020 · Fundamentals

Why Java Needs Lambda: Solving the Vertical Problem with Functional Interfaces

This article explains the need for Java lambda expressions by illustrating the "Vertical Problem" of repetitive, tightly‑coupled code for different contact methods and demonstrates a progression of refactorings that culminate in a concise solution using functional interfaces and predicates.

LambdaPredicateRefactoring
0 likes · 11 min read
Why Java Needs Lambda: Solving the Vertical Problem with Functional Interfaces
Architect's Tech Stack
Architect's Tech Stack
Dec 21, 2020 · Fundamentals

Refactoring Principles, Code Smells, and Refactoring Techniques

This article explains the concept of refactoring, its motivations and timing, enumerates common code smells, and provides detailed refactoring techniques—including extracting methods, moving functions, encapsulating data, simplifying conditionals, and handling inheritance—to improve software design and maintainability.

Best PracticesObject-OrientedRefactoring
0 likes · 21 min read
Refactoring Principles, Code Smells, and Refactoring Techniques
macrozheng
macrozheng
Dec 19, 2020 · Fundamentals

What’s New in IntelliJ IDEA 2020.3? A Deep Dive into the Latest Features

IntelliJ IDEA 2020.3 introduces a revamped welcome screen, reader mode, easier window splitting, enhanced refactoring, upgraded debugging tools, AI‑powered code completion, Search Everywhere improvements, Java 15 support, built‑in database tools, Lombok integration, and a refined VCS menu, all aimed at boosting developer productivity.

DebuggingIDE FeaturesIntelliJ IDEA
0 likes · 7 min read
What’s New in IntelliJ IDEA 2020.3? A Deep Dive into the Latest Features
dbaplus Community
dbaplus Community
Dec 17, 2020 · Backend Development

Scaling from 20K to 1M Users: Service‑Size Strategies and Low‑Cost Refactoring

This article recounts a startup's journey from a tiny serverless stack to a 1‑million‑user architecture, analyzing systemic failures, cost issues, and architectural decay, then proposes service‑size classifications, dependency patterns, and a Minimal Business Unit refactoring approach to achieve scalable, low‑overhead growth.

RefactoringScalabilityServerless
0 likes · 25 min read
Scaling from 20K to 1M Users: Service‑Size Strategies and Low‑Cost Refactoring
phodal
phodal
Dec 7, 2020 · Frontend Development

How to Build an Automated Front‑End Refactoring Tool for Vue Projects

This article outlines a step‑by‑step approach to creating a front‑end automated refactoring tool, covering AST parsing, defining code smells, detection, suggested fixes, implementation of codemods, and practical examples for Vue, JavaScript, TypeScript, CSS, and framework‑specific utilities.

ASTRefactoringVue
0 likes · 6 min read
How to Build an Automated Front‑End Refactoring Tool for Vue Projects
phodal
phodal
Nov 30, 2020 · Frontend Development

Automate CSS Refactoring with Lemonj: A TypeScript‑Powered Analyzer

This article introduces Lemonj, a TypeScript‑based tool that uses Antlr to parse CSS/LESS/SCSS, detect code smells like !important, report their locations, and automatically refactor them across a codebase, complete with installation steps, usage commands, and sample output.

Frontend toolingLemonjRefactoring
0 likes · 5 min read
Automate CSS Refactoring with Lemonj: A TypeScript‑Powered Analyzer
Programmer DD
Programmer DD
Nov 29, 2020 · Frontend Development

Boost Your Productivity: 10 Must‑Know VS Code Tricks for Developers

This article compiles a curated list of practical VS Code techniques—from refactoring code and customizing view layouts to fast debugging, symbol navigation, terminal management, Git operations, and essential shortcuts—offering developers concrete ways to accelerate their workflow and write cleaner code.

DebuggingFrontendRefactoring
0 likes · 12 min read
Boost Your Productivity: 10 Must‑Know VS Code Tricks for Developers
macrozheng
macrozheng
Nov 27, 2020 · Fundamentals

How to Refactor Excessive if‑else Statements for Cleaner Code

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

PolymorphismRefactoringcode maintainability
0 likes · 12 min read
How to Refactor Excessive if‑else Statements for Cleaner Code
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.

Best PracticesRefactoringTechnical debt
0 likes · 13 min read
Why Refactoring Matters: A Practical Guide to Cleaner Code
IT Architects Alliance
IT Architects Alliance
Oct 25, 2020 · R&D Management

From Senior Engineer to Software Architect: A Practical Roadmap

This article outlines a step‑by‑step career roadmap for developers who aspire to become software architects, covering role definitions, required technical and managerial skills, learning pathways such as OOP, design patterns and refactoring, and practical advice for continuous self‑improvement.

Design PatternsR&D ManagementRefactoring
0 likes · 24 min read
From Senior Engineer to Software Architect: A Practical Roadmap
Architecture Digest
Architecture Digest
Sep 25, 2020 · Fundamentals

Refactoring Principles, Code Smells, and Refactoring Techniques

This article explains refactoring as a disciplined way to improve software structure without altering behavior, outlines common code smells, and presents a comprehensive set of refactoring techniques—including extracting functions, moving features, simplifying conditionals, and reorganizing data—illustrated with Java code examples.

Object-OrientedRefactoringclean code
0 likes · 23 min read
Refactoring Principles, Code Smells, and Refactoring Techniques
Amap Tech
Amap Tech
Sep 11, 2020 · Backend Development

Refactoring Java Methods to Simulate Input/Output Parameters

The article explains how Java’s lack of true input‑output parameters can be worked around by refactoring the complex splitLineString method using techniques such as parameter objects, single‑element arrays, mutable tuples, custom holder classes, return objects, ThreadLocal variables, or instance fields, ultimately recommending a generic holder class as the most balanced solution.

InputOutputParametersJavaMethodExtraction
0 likes · 25 min read
Refactoring Java Methods to Simulate Input/Output Parameters
Taobao Frontend Technology
Taobao Frontend Technology
Sep 9, 2020 · Frontend Development

Boost Your Frontend Workflow: 10 Essential VS Code Tips & Tricks

Discover ten practical VS Code techniques—from fast refactoring and custom view layouts to debugging, symbol navigation, split editing, terminal renaming, Git shortcuts, search snapshots, and visual page building—that can dramatically improve your frontend development efficiency and productivity.

DebuggingGitRefactoring
0 likes · 8 min read
Boost Your Frontend Workflow: 10 Essential VS Code Tips & Tricks
Youzan Coder
Youzan Coder
Aug 7, 2020 · Mobile Development

Refactoring the Youzan Mobile Order Module: Architecture Improvements and Historical Code Transformation

The Youzan mobile order module was refactored by separating UI views, turning the monolithic fragment into a ViewModel‑driven architecture, introducing a dynamic router for flexible navigation, and modularizing card components with independent view models, resulting in lower coupling, easier extensions, and a clear gray‑release strategy.

ComponentizationMobile DevelopmentRefactoring
0 likes · 10 min read
Refactoring the Youzan Mobile Order Module: Architecture Improvements and Historical Code Transformation
FunTester
FunTester
Jul 23, 2020 · Fundamentals

Effective Work Practices for Test Development Engineers

The article presents practical tips for test developers, covering pseudocode, task breakdown, version control, refactoring, commenting, solution hunting, embracing change, handling inevitable bugs, and automating repetitive work to improve productivity and code quality.

RefactoringVersion Controlautomation
0 likes · 7 min read
Effective Work Practices for Test Development Engineers
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 PracticesRefactoringcode quality
0 likes · 20 min read
Why Refactoring Matters: Principles, Timing, and Practical Techniques
Java Backend Technology
Java Backend Technology
Jul 16, 2020 · Fundamentals

Boost Your Coding Speed: Hidden IntelliJ IDEA Shortcuts You Must Know

Discover a collection of powerful IntelliJ IDEA shortcuts—including navigation, history view, auto‑completion, variable extraction, renaming, and a serialVersionUID generator plugin—that streamline coding, reduce keystrokes, and boost productivity for developers working on Java projects.

Code navigationIDE shortcutsIntelliJ IDEA
0 likes · 5 min read
Boost Your Coding Speed: Hidden IntelliJ IDEA Shortcuts You Must Know
DevOps
DevOps
Jun 23, 2020 · Fundamentals

Understanding Test‑Driven Development (TDD): Principles, Considerations, Practices, and Challenges

This article explains Test‑Driven Development (TDD) as an agile design methodology, outlines the mindset, requirement analysis, test‑first habits, refactoring and unit‑testing considerations, demonstrates the red‑green‑refactor workflow with examples, and discusses common difficulties and best‑practice tips.

RefactoringTDDdevelopment practices
0 likes · 8 min read
Understanding Test‑Driven Development (TDD): Principles, Considerations, Practices, and Challenges
Sohu Tech Products
Sohu Tech Products
May 20, 2020 · Backend Development

Refactoring an IM System with Dynamic Proxy and RPC Architecture

This article explains how a Java‑based instant‑messaging system was restructured by replacing raw HTTP calls with API packages, introducing dynamic proxies for transparent RPC, and simplifying the code to resemble local method invocations while improving maintainability and scalability.

Dynamic ProxyIM SystemRPC
0 likes · 5 min read
Refactoring an IM System with Dynamic Proxy and RPC Architecture
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 PatternsRefactoringcode quality
0 likes · 19 min read
Eliminating Overused if…else Statements: Refactoring Techniques and Design Patterns
Amap Tech
Amap Tech
May 14, 2020 · Backend Development

Java Code Simplification Techniques and Best Practices

The article compiles a comprehensive set of Java refactoring techniques—ranging from ternary operators, Optional handling, and Stream‑API transformations to Lombok annotations, generics, utility libraries, and design‑pattern applications—aimed at reducing boilerplate, improving readability, and eliminating dead code while preserving functionality and performance.

Code SimplificationJavaLombok
0 likes · 29 min read
Java Code Simplification Techniques and Best Practices
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 PatternsRefactoringcode quality
0 likes · 19 min read
Eliminating Excessive if…else: Patterns and Refactoring Techniques
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 7, 2020 · Fundamentals

Understanding and Applying the Strategy Design Pattern in Java

This article explains the need for flexible sharing functionality, introduces the Strategy design pattern as a way to replace cumbersome if‑else statements, provides Java code examples for the pattern and its usage scenarios, and compares it with the State pattern to improve maintainability and extensibility.

Refactoringdesign-patternsoftware-architecture
0 likes · 9 min read
Understanding and Applying the Strategy Design Pattern in Java
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.

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

IDEOOPRefactoring
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 PatternsRefactoringcode quality
0 likes · 16 min read
Eliminating Excessive if...else Statements: Problems, Solutions, and Refactoring Techniques
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 PatternsRefactoringcode 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 PatternsRefactoringcode 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.

Best PracticesDesign PatternsRefactoring
0 likes · 38 min read
Why Code Quality Matters: 4 Common Pitfalls and Proven Solutions for Developers
Top Architect
Top Architect
Mar 25, 2020 · Fundamentals

Architecture Corruption: Causes, Stages, and Mitigation Strategies

Long‑running software projects inevitably see their initially clean architectures degrade as codebases grow, teams expand, and build times increase, but by understanding the stages of architectural decay and applying practices such as modular isolation, incremental builds, tooling upgrades, and disciplined refactoring, teams can slow or reverse this corrosion.

Build OptimizationRefactoringSoftware Architecture
0 likes · 23 min read
Architecture Corruption: Causes, Stages, and Mitigation Strategies
Top Architect
Top Architect
Feb 12, 2020 · Backend Development

Refactoring a 3000‑Line Legacy Data‑Center Management System to 15 Lines: Lessons and Best Practices

This article recounts how a developer transformed a massive three‑thousand‑line C# data‑center monitoring client into a concise fifteen‑line solution by applying reflection, generics, and systematic refactoring, while sharing practical advice on avoiding code generators, reinventing the wheel, and using unit tests to foster clean architecture.

CRefactoringSoftware Architecture
0 likes · 18 min read
Refactoring a 3000‑Line Legacy Data‑Center Management System to 15 Lines: Lessons and Best Practices
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
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 ManagementRefactoringTechnical debt
0 likes · 9 min read
How to Identify, Break, and Prevent Technical Debt in Software Projects
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-PatternsRefactoringcode quality
0 likes · 6 min read
12 Warning Signs That Your Software Design Is Growing Too Complex
Alibaba Cloud Developer
Alibaba Cloud Developer
Oct 11, 2019 · Backend Development

Boost Java Code Quality: Essential Practices to Eliminate Bad Smells

This article compiles practical Java best‑practice tips—from using entrySet() for map iteration and Collection.isEmpty() for emptiness checks to pre‑sizing collections, avoiding magic numbers, employing try‑with‑resources, and cleaning unused code—helping developers write more efficient, readable, and bug‑free code.

JavaRefactoringcode quality
0 likes · 15 min read
Boost Java Code Quality: Essential Practices to Eliminate Bad Smells
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 30, 2019 · Fundamentals

How to Design Robust Service‑Oriented Architecture and Tame Legacy Code

This article explains the distinction between software design and architecture, outlines core principles for building service‑oriented systems, provides a step‑by‑step method for creating new services, and shares practical strategies for refactoring and migrating legacy code without creating future technical debt.

Design PrinciplesLegacy CodeNBF framework
0 likes · 8 min read
How to Design Robust Service‑Oriented Architecture and Tame Legacy Code