BestHub
Sign in
Tagged articles

refactoring

426 articles · Page 3 of 5
Java Captain
Java Captain
Apr 11, 2023 · Backend Development

Improving Java Backend Code: Bean Conversion, DTO Handling, Lombok, Validation, and Refactoring Practices

This article provides comprehensive guidance on Java backend development, covering IDE selection, bean and DTO conversion techniques, validation with JSR‑303, extensive Lombok usage, builder patterns, proxy design, refactoring strategies, and the balance between business‑driven and technology‑driven development.

DTODesign PatternsJava
0 likes · 25 min read
Improving Java Backend Code: Bean Conversion, DTO Handling, Lombok, Validation, and Refactoring Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 11, 2023 · Fundamentals

Why Software Gets Complex and How to Measure & Tame It

This article examines the root causes of software complexity, explains how to quantify it using metrics such as Halstead, cyclomatic and Ousterhout complexity, showcases real code examples, and offers practical strategies—including high cohesion, low coupling, strategic design, documentation, and refactoring—to prevent and reduce complexity in large systems.

Halsteadcode metricscyclomatic complexity
0 likes · 22 min read
Why Software Gets Complex and How to Measure & Tame It
Bilibili Tech
Bilibili Tech
Apr 7, 2023 · Mobile Development

Design and Refactoring of Inline Video Playback in Feed Streams

The article describes a modular refactor of Bilibili’s feed‑stream inline video playback, introducing a central ModuleInlineManager, ViewHandler, ViewFetcher, and an InlineController that encapsulate player logic, eliminate duplicated code, simplify maintenance, and enable flexible feature testing across diverse feed pages.

architectureiOSinline video
0 likes · 11 min read
Design and Refactoring of Inline Video Playback in Feed Streams
JD Retail Technology
JD Retail Technology
Apr 3, 2023 · Fundamentals

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

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

LearningPerformanceRocketMQ
0 likes · 17 min read
How to Master Clean Code: From Learning to Refactoring with Real Examples
DevOps
DevOps
Mar 21, 2023 · Backend Development

Effective Unit Testing Strategies for Large Legacy Systems

The article shares practical techniques for improving unit test coverage in massive, low‑quality legacy codebases, including creating isolated new modules, applying test‑driven development, decoupling through design patterns, extracting interfaces, using seams, and employing mocking to overcome static dependencies.

Dependency InjectionMockinglegacy code
0 likes · 9 min read
Effective Unit Testing Strategies for Large Legacy Systems
php Courses
php Courses
Mar 14, 2023 · Backend Development

PHP Refactoring Techniques: Naming, Extraction, Early Return, Collections, and Consistency

This article demonstrates practical PHP refactoring techniques—including expressive naming, method extraction, early returns, leveraging Laravel collections, and maintaining code consistency—by showing before-and-after code examples that improve readability, reduce duplication, and simplify logic for backend developers.

Best PracticesLaravelPHP
0 likes · 13 min read
PHP Refactoring Techniques: Naming, Extraction, Early Return, Collections, and Consistency
Alipay Experience Technology
Alipay Experience Technology
Mar 14, 2023 · Frontend Development

Why High-Quality Code Matters: Principles, Bad Smells, and Refactoring Techniques

This article explains why maintainable, robust, and testable code is essential for front‑end development, shares insights from renowned programmers, defines key quality metrics, outlines SOLID and KISS design principles, identifies common code smells, and demonstrates practical refactoring patterns with real JavaScript examples.

KISSSOLIDSoftware Engineering
0 likes · 35 min read
Why High-Quality Code Matters: Principles, Bad Smells, and Refactoring Techniques
High Availability Architecture
High Availability Architecture
Feb 23, 2023 · Backend Development

Clean Code Principles and Practical Java Refactoring Guidelines

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

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

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

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

JavaSoftware Engineeringclean code
0 likes · 17 min read
Why Refactoring Matters: Lessons from "Refactoring" for New Engineers
Code Ape Tech Column
Code Ape Tech Column
Feb 17, 2023 · Backend Development

45 Essential Java Code Quality Tips and Best Practices

This article presents 45 practical Java coding guidelines covering naming conventions, formatting, commenting, method extraction, error handling, thread safety, design patterns, database access, and many other best‑practice techniques to help developers write cleaner, more maintainable backend code.

Best Practicescode qualitycoding standards
0 likes · 27 min read
45 Essential Java Code Quality Tips and Best Practices
Top Architect
Top Architect
Feb 8, 2023 · Fundamentals

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

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

SOLID principlesclean codenaming conventions
0 likes · 18 min read
Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines
macrozheng
macrozheng
Feb 3, 2023 · Fundamentals

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

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

Best Practicesclean coderefactoring
0 likes · 13 min read
Why Clean Code Matters: Practical Tips for Naming, Classes, Functions, and Tests
IT Architects Alliance
IT Architects Alliance
Jan 30, 2023 · Backend Development

From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study

This article explains the concept of software architecture, why architectural styles are chosen, compares monolithic and distributed architectures, analyzes their pros and cons, and walks through a real‑world inventory system migration from a single‑service design to a micro‑service, CQRS‑based distributed solution with code examples and discussion of distributed transactions.

monolithicrefactoringsoftware architecture
0 likes · 16 min read
From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study
21CTO
21CTO
Jan 17, 2023 · Fundamentals

Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration

This guide explains why code review is essential, outlines practical guidelines for reviewers and submitters, shares real‑world practices from leading companies, and highlights common code smells such as DRY, primitive obsession, lock misuse, and pagination problems, helping teams improve code quality and maintainability.

Code Reviewcode qualityrefactoring
0 likes · 20 min read
Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration
IT Architects Alliance
IT Architects Alliance
Jan 14, 2023 · Backend Development

From Monolithic to Distributed Architecture: A Case Study of an Inventory System and CQRS Refactoring

This article explains the concept of software architecture, compares monolithic and distributed styles, discusses their advantages and drawbacks, and details a real-world inventory system migration from a monolithic design to a distributed architecture using functional and business decomposition, CQRS, and code refactoring.

monolithicrefactoringsoftware architecture
0 likes · 17 min read
From Monolithic to Distributed Architecture: A Case Study of an Inventory System and CQRS Refactoring
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 3, 2023 · Fundamentals

Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration

This comprehensive guide explains why code review matters, shares real‑world practices from leading companies, outlines concrete steps for submitters and reviewers, warns against common pitfalls like DRY violations and poor pagination, and offers actionable tips to make reviews effective and sustainable.

Code ReviewSoftware Engineeringcode quality
0 likes · 19 min read
Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration
21CTO
21CTO
Nov 17, 2022 · Fundamentals

Why Clean Code Principles Matter for Every Developer

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

clean codecoding standardsrefactoring
0 likes · 9 min read
Why Clean Code Principles Matter for Every Developer
Sanyou's Java Diary
Sanyou's Java Diary
Oct 20, 2022 · Backend Development

45 Essential Java Coding Practices to Rescue Legacy Code

This article compiles 45 practical Java coding tips—from naming conventions and formatting to exception handling, thread safety, design patterns, and refactoring strategies—aimed at improving readability, maintainability, and performance of existing codebases while preventing common pitfalls.

Best PracticesJavaSoftware Engineering
0 likes · 29 min read
45 Essential Java Coding Practices to Rescue Legacy Code
Architect's Guide
Architect's Guide
Oct 2, 2022 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Java Examples

This article explains the Chain of Responsibility design pattern, its typical use cases, shows problematic implementations, and demonstrates step‑by‑step refactorings—including abstract handlers, client simplification, and enum‑based factory configuration—using clear Java code examples.

Chain of ResponsibilityJavarefactoring
0 likes · 11 min read
Understanding the Chain of Responsibility Design Pattern with Java Examples
dbaplus Community
dbaplus Community
Sep 11, 2022 · Backend Development

Refactoring a Monolithic Inventory System to Distributed Microservices with CQRS

Facing rapid growth and stability issues, the team transformed a monolithic inventory platform into a distributed microservice architecture, employing functional and business decomposition, CQRS principles, and careful code refactoring to improve availability, scalability, and maintainability while addressing challenges like distributed transactions and data consistency.

CQRSarchitecturemicroservices
0 likes · 18 min read
Refactoring a Monolithic Inventory System to Distributed Microservices with CQRS
Selected Java Interview Questions
Selected Java Interview Questions
Sep 11, 2022 · Backend Development

Refactoring Classic Design Patterns with Java 8 Lambdas

This article demonstrates how Java 8’s lambda expressions and functional interfaces can be used to refactor classic design‑pattern implementations—Strategy, Template Method, Observer, and Chain of Responsibility—into more concise, maintainable backend code, providing both traditional Java examples and their streamlined lambda equivalents.

Design PatternsJava8lambda
0 likes · 10 min read
Refactoring Classic Design Patterns with Java 8 Lambdas
Sohu Tech Products
Sohu Tech Products
Sep 7, 2022 · Fundamentals

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

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

Software Engineeringclean coderefactoring
0 likes · 15 min read
Refactoring Techniques: Extract Function, Parameterize, Strategy Pattern, and More
Java High-Performance Architecture
Java High-Performance Architecture
Aug 13, 2022 · Fundamentals

Mastering the Chain of Responsibility Pattern: From Flawed Code to Clean Design

This article explains the Chain of Responsibility design pattern, its typical use cases, shows a problematic nested‑if implementation for a game level system, and demonstrates step‑by‑step refactorings—including a linked‑handler chain and an enum‑based factory—to produce maintainable, extensible Java code.

Chain of ResponsibilityDesign PatternsJava
0 likes · 12 min read
Mastering the Chain of Responsibility Pattern: From Flawed Code to Clean Design
DaTaobao Tech
DaTaobao Tech
Aug 12, 2022 · Backend Development

Evolution and Technical Refactoring of Alibaba's Coupon Package System

Alibaba's coupon package evolved from a 2014 PC‑only tool to a mobile‑centric, marketing‑driven platform, and now to a user‑asset‑center architecture that consolidates assets, upgrades the tech stack, unifies logging, optimizes Docker, and implements performance cuts that shrink machine usage and request expansion by over 90%.

architecturecoupon systemproduct evolution
0 likes · 13 min read
Evolution and Technical Refactoring of Alibaba's Coupon Package System
Architect
Architect
Jun 19, 2022 · Fundamentals

Understanding and Refactoring the Chain of Responsibility Design Pattern in Java

This article explains the Chain of Responsibility design pattern, its typical use cases, shows an anti‑example of overly nested conditional code, and demonstrates step‑by‑step refactoring—including an abstract handler, concrete handlers, and a factory‑based configuration—to achieve cleaner, more maintainable Java implementations.

Chain of ResponsibilityDesign PatternsJava
0 likes · 10 min read
Understanding and Refactoring the Chain of Responsibility Design Pattern in Java
Java Backend Technology
Java Backend Technology
Jun 16, 2022 · Fundamentals

Mastering the Chain of Responsibility Pattern: From Pitfalls to Clean Implementations

This article explains the Chain of Responsibility design pattern, illustrates common misuse with a multi‑if game‑level example, and then shows step‑by‑step refactorings—including linked handlers, an abstract base class, a factory and enum‑based configuration—to produce clean, extensible Java code.

Chain of ResponsibilityDesign Patternrefactoring
0 likes · 12 min read
Mastering the Chain of Responsibility Pattern: From Pitfalls to Clean Implementations
Java Captain
Java Captain
Apr 29, 2022 · Backend Development

Best Practices for Java Bean Conversion, Validation, and Refactoring

This article discusses practical techniques for Java developers, covering bean conversion using DTOs and Spring utilities, validation with JSR‑303, leveraging Lombok for cleaner code, applying design patterns, and systematic refactoring to improve readability, maintainability, and overall code quality in backend projects.

DTOJavaLombok
0 likes · 27 min read
Best Practices for Java Bean Conversion, Validation, and Refactoring
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 16, 2022 · Backend Development

Refactoring Zhaunzhuan App Backend Routing with the Aviator Expression Engine

The article describes how the Zhaunzhuan app backend team replaced a hard‑coded Map‑based routing configuration with a rule‑driven Aviator expression engine, detailing the problem analysis, engine selection, architectural redesign, code changes, a deployment incident, and the resulting improvements in flexibility, maintainability, and performance.

AviatorBackendConfiguration
0 likes · 10 min read
Refactoring Zhaunzhuan App Backend Routing with the Aviator Expression Engine
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 PatternsEnum
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 extensionsJetBrainscode quality
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.

Coding Best PracticesJavacode 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 PracticesJavaSoftware Engineering
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 PatternsJavaSpring
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.

Performanceasync/awaitfrontend
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.

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

Code ReadabilityESLintJavaScript
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 PracticesCode ReadabilitySoftware Engineering
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.

DRYcode duplicationrefactoring
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.

JavaScriptPromisePure Functions
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.

Plugin Architecturebuild-toolfrontend
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.

clean codecode smellsrefactoring
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.

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

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

IDEASingle Responsibilitycode 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 pyramid
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.

IDEASingle Responsibility PrincipleSoftware Engineering
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.

HTML5JavaScriptWeb Streaming
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 PracticesJavaScriptcode smells
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-configurationmodularizationrefactoring
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.

Backendcloud-nativemicroservices
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 Patternscode qualitymaintainability
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.

Domain-Driven Designcode qualitydesign principles
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.

bad practiceclean codecode smell
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.

JavaPredicatesfunctional programming
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 Practicesclean coderefactoring
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 OptimizationPlatform Designcode decay
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.

Code Readabilityclean coderefactoring
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 IDEAkeyboard shortcuts
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.

Rule Enginerefactoringshort-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.

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
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 PatternsJavaStrategy Pattern
0 likes · 10 min read
Understanding the Strategy Design Pattern in Java
Architect's Tech Stack
Architect's Tech Stack
Apr 11, 2021 · Fundamentals

Refactoring Principles, Code Smells, and Practical Techniques for Improving Software Design

This article explains the concept of refactoring, why and when to refactor, enumerates common code smells, and presents concrete techniques such as extracting functions, moving methods or fields, and reorganizing class hierarchies to produce cleaner, more maintainable object‑oriented code.

Object-Oriented Programmingclean codecode smells
0 likes · 24 min read
Refactoring Principles, Code Smells, and Practical Techniques for Improving Software Design
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.

architecturedata migrationlegacy system
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.

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

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

@AsyncJavaScriptPromise
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 PracticesJavaSOLID
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 PracticesPHPcode quality
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 PracticesJavaSoftware Engineering
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 TechBackendproject management
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.

C++Software EngineeringTDD
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.

clean codecode qualitycode smells
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.

Predicatefunctional-programminglambda
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 Practicesclean codecode smells
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.

IDE FeaturesIntelliJ IDEAJava 15
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.

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

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

CSSFrontend toolingLemonj
0 likes · 5 min read
Automate CSS Refactoring with Lemonj: A TypeScript‑Powered Analyzer