Tagged articles

refactoring

398 articles · Page 3 of 4

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 ResponsibilityJavadesign patterns

0 likes · 12 min read

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

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

Coupon Systemarchitectureproduct evolution

0 likes · 13 min read

Evolution and Technical Refactoring of Alibaba's Coupon Package System

Architecture Digest

Jul 11, 2022 · Fundamentals

Chain of Responsibility Design Pattern: Concepts, Drawbacks, and Refactoring in Java

This article explains the Chain of Responsibility design pattern, its use cases, and demonstrates step‑by‑step refactoring in Java—from a verbose conditional example to a clean, extensible handler chain, including abstract handlers, concrete handlers, and a factory‑based configuration.

Chain of ResponsibilityJavadesign patterns

0 likes · 13 min read

Chain of Responsibility Design Pattern: Concepts, Drawbacks, and Refactoring in Java

IT Architects Alliance

Jun 20, 2022 · Fundamentals

Understanding and Refactoring the Chain of Responsibility Design Pattern in Java

This article explains the Chain of Responsibility pattern, its typical use cases, shows a problematic implementation for a game level system, and demonstrates how to refactor the code using abstract handlers, concrete handlers, and a factory to build a clean, extensible processing chain in Java.

Chain of ResponsibilityJavarefactoring

0 likes · 12 min read

Understanding and Refactoring the Chain of Responsibility Design Pattern in Java

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 ResponsibilityJavadesign patterns

0 likes · 10 min read

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

Alibaba Cloud Developer

Jun 14, 2022 · Fundamentals

When Are Code Comments Worth It? Exploring the Debate on Self‑Documenting Code

This article examines the purpose and controversy of code comments, arguing that while well‑written code should be self‑explanatory, strategic comments can bridge gaps in readability, aid maintenance, and convey intent, especially in complex or legacy codebases.

best practicesclean codecode comments

0 likes · 19 min read

When Are Code Comments Worth It? Exploring the Debate on Self‑Documenting Code

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

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.

AviatorConfigurationExpression Engine

0 likes · 10 min read

Refactoring Zhaunzhuan App Backend Routing with the Aviator Expression Engine

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 ClassEnumPython

0 likes · 14 min read

Refactoring a Python Employee Management System to Eliminate Code Smells

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

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.

Javacode qualitycoding best practices

0 likes · 32 min read

20 Common Coding Pitfalls and How to Avoid Them

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.

Javabest practicescode quality

0 likes · 38 min read

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

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.

JavaSpringStrategy Pattern

0 likes · 15 min read

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

Tencent IMWeb Frontend Team

Jan 27, 2022 · Frontend Development

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

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

Database Designbackendcode quality

0 likes · 20 min read

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

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.

ESLintJavaScriptNaming Conventions

0 likes · 10 min read

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

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 readabilitynaming

0 likes · 17 min read

Why Good Naming Is the Secret Weapon for Clean Code

Open Source Linux

Dec 19, 2021 · Fundamentals

Boost Your Python Productivity: 38 Essential PyCharm Shortcuts

This guide compiles the most useful PyCharm keyboard shortcuts—covering code formatting, navigation, refactoring, debugging, and more—to help Python developers work faster and write cleaner code with fewer mouse clicks.

Code formattingIDEShortcuts

0 likes · 13 min read

Boost Your Python Productivity: 38 Essential PyCharm Shortcuts

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

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

Nov 25, 2021 · Frontend Development

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

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

Async/AwaitJavaScriptPromise

0 likes · 11 min read

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

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 toolfrontendimflow

0 likes · 37 min read

How IMFLOW Was Re‑Engineered: From Monolithic Tool to Modular Build‑Kit 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

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

Python Programming Learning Circle

Oct 13, 2021 · Fundamentals

Essential PyCharm Keyboard Shortcuts for Efficient Python Development

This guide presents a comprehensive collection of PyCharm keyboard shortcuts—including code formatting, line merging, comment toggling, navigation, refactoring, and debugging—illustrated with clear Python examples to help developers write, organize, and troubleshoot code more quickly and accurately.

Code formattingIDE shortcutsPython

0 likes · 10 min read

Essential PyCharm Keyboard Shortcuts for Efficient Python Development

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.

IDEPythonTips

0 likes · 8 min read

11 Essential PyCharm Tips to Supercharge Your Python Workflow

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.

IDEAcode qualityrefactoring

0 likes · 9 min read

Why Long Classes Are Problematic and How to Refactor Them

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.

Test‑Driven Developmentrefactoringsoftware quality

0 likes · 11 min read

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

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.

IDEAclass designcode quality

0 likes · 8 min read

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

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.

HTML5JavaScriptRTMP

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

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.

JavaScriptbest practicescode smells

0 likes · 27 min read

Why Refactoring Matters: Practical Tips and Code Smell Solutions

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

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 NativeMicroservicesbackend

0 likes · 13 min read

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

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.

code qualitydesign patternsmaintainability

0 likes · 38 min read

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

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

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

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

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

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?

Fulu Network R&D Team

Jun 24, 2021 · Frontend Development

Refactoring a Hybrid App SDK from JavaScript to TypeScript with Type Definitions and Build Configuration

This article describes how to refactor a large JavaScript hybrid‑app SDK into TypeScript, set up Rollup and Babel for building, create proper .d.ts type definitions, use generics, overloads, and type guards, and solve path‑alias issues for reliable IDE support.

TypeScriptfrontendgenerics

0 likes · 9 min read

Refactoring a Hybrid App SDK from JavaScript to TypeScript with Type Definitions and Build Configuration

MaGe Linux Operations

Jun 21, 2021 · Fundamentals

Mastering Code Quality: SOLID Principles, Architecture & Refactoring Techniques

This article explains how to instantly improve program design by mastering the five SOLID principles, understanding three common architectures, using diagrams, choosing clear names, and optimizing nested if‑else logic, all illustrated with Python code examples and visual diagrams.

SOLIDcode qualitydesign patterns

0 likes · 20 min read

Mastering Code Quality: SOLID Principles, Architecture & Refactoring Techniques

ByteDance Dali Intelligent Technology Team

Jun 20, 2021 · Frontend Development

Practical Refactoring Guidance for Client‑Side Development

This article offers practical engineering guidance on when and how to refactor client‑side code, emphasizing planning, incremental changes, systematic approaches, tooling, and team coordination to improve code quality while minimizing risk and maintaining system stability.

client-sidecode qualityrefactoring

0 likes · 19 min read

Practical Refactoring Guidance for Client‑Side Development

KooFE Frontend Team

Jun 14, 2021 · Fundamentals

How to Write Clean, Readable JavaScript Code: Essential Practices

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

clean codecode readabilityrefactoring

0 likes · 11 min read

How to Write Clean, Readable JavaScript Code: Essential Practices

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

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

ITFLY8 Architecture Home

May 23, 2021 · Fundamentals

Why Refactoring Matters: Eliminate Code Smells with SOLID Principles and Design Patterns

This article explains the importance of refactoring, identifies common code smells, introduces SOLID principles and design patterns, and provides practical techniques—including method extraction, guard clauses, polymorphism, and composition—to improve code readability, maintainability, and testability.

SOLIDTDDcode quality

0 likes · 44 min read

Why Refactoring Matters: Eliminate Code Smells with SOLID Principles and Design Patterns

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

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.

SOLIDTDDcode quality

0 likes · 36 min read

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

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.

JavaStrategy Patterndesign patterns

0 likes · 10 min read

Understanding the Strategy Design Pattern in Java

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

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 MigrationMicroservicesarchitecture

0 likes · 8 min read

When and How to Refactor Legacy Systems into Microservices

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

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

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.

JavaScriptPromiseasync

0 likes · 10 min read

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

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.

JavaSOLIDbest practices

0 likes · 14 min read

Mastering Code Smells: Identify and Refactor Common Bad Practices

php Courses

Feb 3, 2021 · Backend Development

Practical Refactoring Tips for Cleaner PHP Code

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

PHPbest practicescode quality

0 likes · 9 min read

Practical Refactoring Tips for Cleaner PHP Code

JD Tech Talk

Feb 1, 2021 · Mobile Development

Refactoring JD Pay Android SDK: Architecture Redesign with Scene, Interactor, and UserCase

This article details the challenges of JD Pay's Android SDK growth, proposes a refactor using Scene, Interactor, and UserCase concepts to decouple business logic, presents architectural redesign, code examples, and quantitative performance improvements after the overhaul.

AndroidMobile Developmentarchitecture

0 likes · 15 min read

Refactoring JD Pay Android SDK: Architecture Redesign with Scene, Interactor, and UserCase

Alibaba Cloud Native

Jan 20, 2021 · Backend Development

How Refactoring Seata’s RPC Module Simplifies Communication Logic

This article details the step‑by‑step refactor of Seata's RPC module, explaining the original inheritance problems, the new class hierarchy, decoupled processing logic, and improved request handling for clearer, more maintainable backend communication.

JavaProcessor PatternRPC

0 likes · 9 min read

How Refactoring Seata’s RPC Module Simplifies Communication Logic

Alibaba Terminal Technology

Jan 15, 2021 · Frontend Development

How RxJS Was Refactored to Be Smaller and Faster – Insights from D2 Session

The D2 Language & Framework session covered Ben Lesh’s RxJS refactoring to reduce bundle size and boost speed, Ujjwal’s deep dive into ES2020/2021 features, monadic lift functions versus optional chaining, and practical performance gains achievable by targeting modern JavaScript standards.

ES2020JavaScriptMonads

0 likes · 9 min read

How RxJS Was Refactored to Be Smaller and Faster – Insights from D2 Session

Continuous Delivery 2.0

Jan 14, 2021 · Backend Development

Mob Programming Refactoring Experience: Restoring Missing Domain Objects

The article recounts a 2009 GoCD team mob‑programming session where developers collaboratively refactored a module, identified missing domain objects, applied a strong refactoring environment and automated tests, and transformed flawed Java code into a cleaner, domain‑driven design.

Domain-Driven DesignJavarefactoring

0 likes · 6 min read

Mob Programming Refactoring Experience: Restoring Missing Domain Objects

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.

Javabest practicescode quality

0 likes · 14 min read

10 Practical Java Refactoring Techniques Every Developer Should Master

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

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#TDDgtest

0 likes · 10 min read

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

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

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.

LambdaPredicatefunctional-programming

0 likes · 11 min read

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

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

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

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.

ServerlessService Architecturebackend

0 likes · 25 min read

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

Qunar Tech Salon

Dec 9, 2020 · Backend Development

Improving L‑D Stage Smoothness and Refactoring the Rebuild System for International Hotel Pricing

This article details how the L‑D stage of international hotel pricing was optimized through a new offline‑fetch scheduling mechanism, cache‑freshness calculations, and a comprehensive refactor of the rebuild system, resulting in lower latency, higher throughput, and a smoother user experience.

CachingSchedulingSystem Design

0 likes · 11 min read

Improving L‑D Stage Smoothness and Refactoring the Rebuild System for International Hotel Pricing

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.

ASTAutomationVue

0 likes · 6 min read

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

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 toolingLemonjTypeScript

0 likes · 5 min read

Automate CSS Refactoring with Lemonj: A TypeScript‑Powered Analyzer

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.

ShortcutsVS Codedebugging

0 likes · 12 min read

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

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.

code maintainabilityif-elsepolymorphism

0 likes · 12 min read

How to Refactor Excessive if‑else Statements for Cleaner Code

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 practicesclean codecode quality

0 likes · 13 min read

Why Refactoring Matters: A Practical Guide to Cleaner Code

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.

R&D Managementcareer developmentdesign patterns

0 likes · 24 min read

From Senior Engineer to Software Architect: A Practical Roadmap

Huawei Cloud Developer Alliance

Oct 13, 2020 · Fundamentals

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

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

code qualitydeveloper culturerefactoring

0 likes · 13 min read

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

Java Architecture Diary

Oct 13, 2020 · Backend Development

Master IntelliJ IDEA: Code Formatting, UML, Spring Boot Mapping & Debugging

This guide shows how to quickly reformat code without opening settings, generate UML class diagrams, view and test Spring Boot endpoint mappings, navigate debugging execution points, and rename methods using IntelliJ IDEA Ultimate shortcuts, enhancing productivity for Java developers.

Code formattingIntelliJ IDEASpring Boot

0 likes · 3 min read

Master IntelliJ IDEA: Code Formatting, UML, Spring Boot Mapping & Debugging

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.

clean codecode smellsobject-oriented

0 likes · 23 min read

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

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.

GitVS Codedebugging

0 likes · 8 min read

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

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 DevelopmentRouting

0 likes · 10 min read

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

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.

AutomationVersion Controlrefactoring

0 likes · 7 min read

Effective Work Practices for Test Development Engineers

QQ Music Frontend Team

Jul 20, 2020 · Fundamentals

Why Refactoring Matters: Principles, Timing, and Practical Techniques

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

best practicescode qualityrefactoring

0 likes · 20 min read

Why Refactoring Matters: Principles, Timing, and Practical Techniques

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

Continuous Delivery 2.0

Jul 15, 2020 · Fundamentals

When Constructors Do Too Much Work: Symptoms, Risks, and Refactoring Techniques

The article explains why having constructors perform excessive work is a design flaw, describes how to spot this problem through code symptoms, discusses its impact on testability and maintainability, and provides concrete refactoring strategies such as dependency injection, factories, and builder patterns.

Dependency InjectionUnit Testingcode smell

0 likes · 13 min read

When Constructors Do Too Much Work: Symptoms, Risks, and Refactoring Techniques

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.

TDDdevelopment practicesrefactoring

0 likes · 8 min read

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

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

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.

code qualitydesign patternsif-else

0 likes · 19 min read

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

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

Continuous Delivery 2.0

May 11, 2020 · Fundamentals

Reducing Nesting and Promoting Respectful Code Reviews – Insights from Google’s Code Health Guide

This article translates Google’s Code Health Guide, explaining how reducing deep nesting with guard‑clauses improves readability and bug detection, and offering concrete, respectful code‑review practices that foster clearer communication and higher software quality.

code qualityguard-clausesrefactoring

0 likes · 5 min read

Reducing Nesting and Promoting Respectful Code Reviews – Insights from Google’s Code Health Guide

Continuous Delivery 2.0

May 10, 2020 · Fundamentals

Eliminating YAGNI Smell, When to Use Comments, and Effective Code Review Practices

This article explains how to identify and remove YAGNI code smells, discusses when comments are helpful versus harmful, and provides practical guidelines for conducting efficient code reviews to improve software quality and maintainability.

YAGNIcommentsrefactoring

0 likes · 9 min read

Eliminating YAGNI Smell, When to Use Comments, and Effective Code Review Practices

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.

code qualitydesign patternsif-else

0 likes · 19 min read

Eliminating Excessive if…else: Patterns and Refactoring Techniques

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.

design-patternrefactoringsoftware-architecture

0 likes · 9 min read

Understanding and Applying the Strategy Design Pattern in Java

Programmer DD

May 5, 2020 · Fundamentals

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

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

IDEAJavacode quality

0 likes · 8 min read

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

Java Backend Technology

May 5, 2020 · Fundamentals

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

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

IDEOOPcode quality

0 likes · 8 min read

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

Python Crawling & Data Mining

Apr 30, 2020 · Backend Development

10 Essential PyCharm Tricks to Supercharge Your Python Development

Discover ten powerful PyCharm shortcuts and features—from automatic imports and batch refactoring to quick navigation and code cleanup—that can dramatically boost your Python development efficiency, streamline workflow, and help you write cleaner code with fewer keystrokes.

IDEPythonShortcuts

0 likes · 8 min read

10 Essential PyCharm Tricks to Supercharge Your Python Development

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.

code qualitydesign patternsif-else

0 likes · 16 min read

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

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.

code qualitydesign patternsif-else

0 likes · 16 min read

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

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.

code qualitydesign patternsmaintainability

0 likes · 37 min read

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