BestHub
Sign in
Tagged articles

refactoring

398 articles · Page 4 of 4
macrozheng
macrozheng
Apr 14, 2020 · Fundamentals

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

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

best practicescode qualitydesign patterns
0 likes · 38 min read
Why Code Quality Matters: 4 Common Pitfalls and Proven Solutions for Developers
Top Architect
Top Architect
Mar 25, 2020 · Fundamentals

Architecture Corruption: Causes, Stages, and Mitigation Strategies

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

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

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

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

C#Unit Testingcode generation
0 likes · 18 min read
Refactoring a 3000‑Line Legacy Data‑Center Management System to 15 Lines: Lessons and Best Practices
Architecture Digest
Architecture Digest
Feb 6, 2020 · Backend Development

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

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

Backend DevelopmentC#Unit Testing
0 likes · 18 min read
Refactoring a 3000‑Line C# System to 15 Lines: Lessons and Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 19, 2020 · Fundamentals

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

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

code qualityproject managementrefactoring
0 likes · 9 min read
How to Identify, Break, and Prevent Technical Debt in Software Projects
21CTO
21CTO
Jan 3, 2020 · Fundamentals

12 Warning Signs That Your Software Design Is Growing Too Complex

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

Anti-patternscode qualitycomplexity
0 likes · 6 min read
12 Warning Signs That Your Software Design Is Growing Too Complex
Alibaba Cloud Developer
Alibaba Cloud Developer
Oct 11, 2019 · Backend Development

Boost Java Code Quality: Essential Practices to Eliminate Bad Smells

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

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

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

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

Legacy CodeNBF frameworkdesign principles
0 likes · 8 min read
How to Design Robust Service‑Oriented Architecture and Tame Legacy Code
Architect's Tech Stack
Architect's Tech Stack
Sep 26, 2019 · Fundamentals

Refactoring Principles, Code Smells, and Techniques for Improving Code Quality

This article explains why and how to refactor legacy code by defining refactoring principles, describing common code smells, and presenting concrete techniques such as extracting functions, moving fields, introducing explanatory variables, and reorganizing data and inheritance hierarchies to produce cleaner, more maintainable software.

code qualityrefactoringsoftware engineering
0 likes · 23 min read
Refactoring Principles, Code Smells, and Techniques for Improving Code Quality
Java Captain
Java Captain
Sep 17, 2019 · Backend Development

Java Function Coding Guidelines: Primitive Types, Parameter Classes, and Refactoring Best Practices

This article presents a series of Java function coding guidelines—including using primitive types for parameters and return values, avoiding null arrays or lists, encapsulating many parameters into objects, replacing anonymous inner classes with functions, simplifying control flow, and employing temporary variables—to improve code readability, maintainability, and robustness.

Javabest practicescode readability
0 likes · 19 min read
Java Function Coding Guidelines: Primitive Types, Parameter Classes, and Refactoring Best Practices
Java Backend Technology
Java Backend Technology
Sep 14, 2019 · Fundamentals

Master Code Refactoring: Principles, Smells, and Practical Techniques

This article explains what refactoring is, why and when to apply it, lists common code smells with concrete examples, and provides step‑by‑step techniques for reorganizing functions, moving responsibilities, restructuring data, simplifying conditionals, and improving overall software design.

clean codecode smellsobject-oriented
0 likes · 27 min read
Master Code Refactoring: Principles, Smells, and Practical Techniques
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 11, 2019 · Fundamentals

What Makes Code Truly Good? Essential Principles and Practices

This article explores the essential characteristics of clean code, emphasizing high cohesion, low coupling, readability, proper naming, formatting, concise classes and functions, effective comments, error handling, and common code smells, while providing practical guidelines and examples for developers.

clean codecode qualityrefactoring
0 likes · 11 min read
What Makes Code Truly Good? Essential Principles and Practices
Programmer DD
Programmer DD
Sep 6, 2019 · Fundamentals

Boost Your Java Productivity: Top IntelliJ IDEA Shortcuts You Must Know

This guide compiles essential IntelliJ IDEA shortcuts—including automatic code generation, navigation, editing, debugging, and refactoring keys—organized by function, to help Java developers work faster, reduce mouse reliance, and streamline everyday coding tasks.

IDE shortcutsIntelliJJava development
0 likes · 14 min read
Boost Your Java Productivity: Top IntelliJ IDEA Shortcuts You Must Know
21CTO
21CTO
Aug 28, 2019 · Fundamentals

6 Proven Techniques to Write Clean, Maintainable Code

This article explains why clean code matters—reducing reading time, easing project continuation, speeding up new‑developer onboarding, and supporting consistent coding patterns—and provides six practical tips, from readable formatting to regular code reviews, to help developers produce cleaner, more maintainable software.

Programming Fundamentalsclean codecode readability
0 likes · 11 min read
6 Proven Techniques to Write Clean, Maintainable Code
Architect's Tech Stack
Architect's Tech Stack
Aug 11, 2019 · Fundamentals

Refactoring Principles and Code Smells: A Comprehensive Guide

This article presents a thorough overview of refactoring principles, common code smells, and practical techniques for improving software structure, including extracting functions, moving methods, simplifying conditionals, and reorganizing data, aimed at helping developers write cleaner, more maintainable code.

clean-codecode-smellsrefactoring
0 likes · 22 min read
Refactoring Principles and Code Smells: A Comprehensive Guide
Java Backend Technology
Java Backend Technology
Jul 17, 2019 · Backend Development

Why IntelliJ IDEA Beats Eclipse for Java Development: A Deep Dive

This article compares IntelliJ IDEA and Eclipse, highlighting IDEA’s superior context‑aware debugging, auto‑completion, and refactoring features, while acknowledging Eclipse’s strengths in other languages and as a plugin platform, to help Java developers choose the right IDE.

EclipseIntelliJ IDEAJava IDE
0 likes · 9 min read
Why IntelliJ IDEA Beats Eclipse for Java Development: A Deep Dive
Continuous Delivery 2.0
Continuous Delivery 2.0
Jul 11, 2019 · Fundamentals

Seven Practical Techniques for Writing Testable Code

Writing unit-testable code often requires refactoring, and by focusing on minimizing function size, dependencies, and complexity, developers can adopt seven practical techniques—including limiting function lines, single responsibility, dependency injection, avoiding complex parameters, using abstractions, extracting testable units, and handling private functions—to improve testability and team efficiency.

Unit Testingbest practicesrefactoring
0 likes · 6 min read
Seven Practical Techniques for Writing Testable Code
Java Captain
Java Captain
May 4, 2019 · Backend Development

Refactoring a Core Business System: Lessons Learned and Best Practices

The article recounts a 2014 experience of refactoring a critical business system after a serious bug, detailing how the team defined scope, designed dual‑flow verification with gray releases, managed expectations, and successfully delivered a maintainable backend solution.

Microservicesbackendgray-release
0 likes · 8 min read
Refactoring a Core Business System: Lessons Learned and Best Practices
NetEase Game Operations Platform
NetEase Game Operations Platform
Apr 27, 2019 · Frontend Development

Functional Programming in JavaScript: Refactoring User List Processing

This article demonstrates how to apply functional programming concepts in JavaScript by refactoring an example that reads user data from an API, filters active SREs, and formats output, illustrating the benefits of pure functions, higher‑order utilities like map, filter, reduce, and improved code readability and maintainability.

Functional ProgrammingHigher-Order FunctionsPure Functions
0 likes · 22 min read
Functional Programming in JavaScript: Refactoring User List Processing
Programmer DD
Programmer DD
Apr 26, 2019 · Fundamentals

Why IntelliJ IDEA Beats Eclipse: 3 Powerful Features You’re Missing

The article compares IntelliJ IDEA and Eclipse for Java development, highlighting IDEA’s context‑aware debugging, smarter code completion, and advanced refactoring, while acknowledging Eclipse’s strengths such as plugin flexibility and lower resource usage, and concludes with guidance on choosing the right IDE.

EclipseIntelliJ IDEAJava IDE
0 likes · 9 min read
Why IntelliJ IDEA Beats Eclipse: 3 Powerful Features You’re Missing
Java Backend Technology
Java Backend Technology
Mar 10, 2019 · Fundamentals

Mastering Code Refactoring: Principles, Smells, and Practical Techniques

Refactoring transforms messy code into clean, maintainable structures without altering observable behavior, covering principles, common code smells, and step‑by‑step techniques such as extracting functions, moving methods, simplifying conditionals, and reorganizing data, empowering developers to improve design, reduce bugs, and accelerate development.

best practicesclean codecode smells
0 likes · 26 min read
Mastering Code Refactoring: Principles, Smells, and Practical Techniques
21CTO
21CTO
Jan 21, 2019 · Fundamentals

How to Write Clean, Maintainable Code: Refactoring and Naming Best Practices

This guide explains why writing high‑quality code matters, outlines essential principles such as thoughtful design, using tools like SonarQube, proper class, method, variable, and constant naming, and demonstrates refactoring techniques with Java examples to produce more readable and robust software.

Naming Conventionsbest practicescode quality
0 likes · 8 min read
How to Write Clean, Maintainable Code: Refactoring and Naming Best Practices
Zhuanzhuan Tech
Zhuanzhuan Tech
Jan 17, 2019 · Backend Development

Design and Refactoring of the Book Outbound Service with SN Allocation and Concurrency Management

The article describes the challenges of handling book outbound operations—matching SN codes, ensuring data consistency, and avoiding lock contention—and outlines a comprehensive refactor that separates business logic, standardizes APIs, adopts asynchronous processing, and leverages Redis sets to achieve high‑performance, reliable SN allocation.

InventoryRedisbackend
0 likes · 10 min read
Design and Refactoring of the Book Outbound Service with SN Allocation and Concurrency Management
Programmer DD
Programmer DD
Jan 3, 2019 · Backend Development

7 Proven Tips to Write Cleaner, More Efficient Java Code

This article presents seven practical techniques—including using IntelliJ IDEA, upgrading to JDK 8+, adopting Maven/Gradle, leveraging Lombok, writing unit tests, refactoring incrementally, and gathering regular customer feedback—to help developers produce shorter, clearer, and more maintainable Java code.

Coding TipsIntelliJ IDEAJava
0 likes · 7 min read
7 Proven Tips to Write Cleaner, More Efficient Java Code
Beike Product & Technology
Beike Product & Technology
Nov 30, 2018 · Mobile Development

Refactoring a 2000‑Line Android Detail Page to Under 200 Lines Using MVP and Modularization

This article describes how a large, tightly‑coupled Android detail page was refactored into a clean, modular MVP architecture that splits business logic into reusable Parts, reducing the file size from over 2000 lines to fewer than 200 while improving readability, maintainability, and rendering performance.

AndroidMVPMobile Development
0 likes · 18 min read
Refactoring a 2000‑Line Android Detail Page to Under 200 Lines Using MVP and Modularization
Architecture Digest
Architecture Digest
Aug 5, 2018 · Fundamentals

Why Programmers Refactor Code and How to Do It Effectively

The article examines why developers feel compelled to refactor messy code, illustrates common pitfalls such as mixing refactoring with new feature development, and proposes practical strategies—including separating refactoring from feature work, adopting small‑step incremental changes, and integrating test‑driven development—to manage refactoring projects successfully.

code qualitydevelopment processproject management
0 likes · 6 min read
Why Programmers Refactor Code and How to Do It Effectively
Java Captain
Java Captain
Jul 22, 2018 · Fundamentals

Best Practices for Writing Clean and Maintainable Code

This article summarizes essential clean‑code practices—including commenting, naming, method design, exception handling, concurrency, unit testing, and overall code structure—to help engineers write elegant, readable, and maintainable software.

Code styleNaming ConventionsUnit Testing
0 likes · 10 min read
Best Practices for Writing Clean and Maintainable Code
dbaplus Community
dbaplus Community
Jul 18, 2018 · Backend Development

How We Refactored a 66k‑Line Home Page to Cut Feature Delivery from Days to Hours

The article recounts how a monolithic 66,000‑line home‑page system with high latency and tangled logic was re‑engineered through clear direction, module‑based design, and incremental changes, resulting in dramatically faster feature rollout, lower learning cost, and improved performance metrics.

Backend Engineeringmodular architecturerefactoring
0 likes · 10 min read
How We Refactored a 66k‑Line Home Page to Cut Feature Delivery from Days to Hours
Java Backend Technology
Java Backend Technology
Jul 12, 2018 · Fundamentals

How to Write Clean, Readable Code: Practical Tips from the Classics

This article distills essential clean‑code practices—covering comments, naming, method design, error handling, concurrency, unit testing, structure, and design—drawn from classic books and real‑world engineering experience to help developers produce elegant, maintainable software.

best practicesclean codecode readability
0 likes · 13 min read
How to Write Clean, Readable Code: Practical Tips from the Classics
Architecture Digest
Architecture Digest
Jul 2, 2018 · Backend Development

Reflections on Software Service Architecture: From Three‑Tier to Microservices and High Concurrency

This article shares practical insights on evolving from traditional three‑tier architecture to microservice‑based designs, discusses fine‑grained versus coarse‑grained service partitioning, addresses high‑concurrency challenges, and proposes refactoring strategies for large‑scale backend systems.

High concurrencyThree-tierrefactoring
0 likes · 7 min read
Reflections on Software Service Architecture: From Three‑Tier to Microservices and High Concurrency
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
May 9, 2018 · Fundamentals

From Coder to Software Engineer: The Three Stages Every Programmer Must Master

The article reflects on a programmer’s personal journey, explains why coding sharpens logical thinking and creativity, outlines the three professional stages—Coder, Programmer, Software Engineer—and shares a concrete refactoring case that illustrates how focus and good design separate true engineers from mere code farmers.

Coding Practicescareer developmentprogrammer stages
0 likes · 9 min read
From Coder to Software Engineer: The Three Stages Every Programmer Must Master
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 3, 2018 · Fundamentals

How to Cultivate Object‑Oriented Thinking and Architecture Skills as a Junior Developer

After years of coding without guidance, the author shares practical insights on developing object‑oriented design thinking, when to use interfaces, the limits of OOD, and how continuous refactoring and learning design patterns can gradually build a junior developer’s architectural competence.

Object-Oriented Designdesign patternsrefactoring
0 likes · 11 min read
How to Cultivate Object‑Oriented Thinking and Architecture Skills as a Junior Developer
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 7, 2018 · Fundamentals

Mastering Refactoring: When and How to Move Methods, Fields, and Classes

This article explains core refactoring techniques—Move Method, Move Field, Extract Class, Inline Class, Hide Delegate, Remove Middle Man, Introduce Foreign Method, and Introduce Local Extension—showing when to apply each, how to identify candidates, and the benefits for cleaner, more maintainable object‑oriented code.

Object-Oriented Designextract classmove method
0 likes · 11 min read
Mastering Refactoring: When and How to Move Methods, Fields, and Classes
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 7, 2018 · Fundamentals

Master Refactoring: When to Extract, Inline, and Replace Methods

This article explains key refactoring techniques—Extract Method, Inline Method, Inline Temp, Introduce Explaining Variable, Split Temporary Variable, Remove Assignments to Parameters, and Replace Method with Method Object—showing when to apply each, why they improve code clarity, and providing Java code examples for each transformation.

code qualityextract-methodinline method
0 likes · 13 min read
Master Refactoring: When to Extract, Inline, and Replace Methods
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 5, 2018 · Fundamentals

How to Eliminate 22 Common Code Smells with Refactoring Techniques

This article enumerates twenty‑two typical code smells—from duplicated code and long methods to speculative generality—and provides concrete refactoring tactics such as Extract Method, Pull Up Method, Introduce Parameter Object, and Move Method to improve design, readability, and maintainability of object‑oriented software.

clean codecode smellsobject-oriented
0 likes · 24 min read
How to Eliminate 22 Common Code Smells with Refactoring Techniques
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 2, 2018 · Backend Development

From Coder to Web Architect: Essential Skills, Mindset, and Roadmap

This article outlines the philosophical questions, practical steps, and essential knowledge—ranging from object‑oriented fundamentals and design patterns to refactoring, DBA, and operations—that developers need to master in order to evolve into competent web architects.

Object-Oriented Programmingcareer developmentdesign patterns
0 likes · 19 min read
From Coder to Web Architect: Essential Skills, Mindset, and Roadmap
Architects' Tech Alliance
Architects' Tech Alliance
Jan 17, 2018 · Fundamentals

Five Practical Ways to Improve and Maintain Code Written by Others

The article outlines five actionable strategies—ensuring tests exist, communicating with the original author, eliminating warnings, refactoring, and making the code better than when found—to responsibly modify and enhance legacy code while minimizing risk and technical debt.

Legacy Codecode reviewcommunication
0 likes · 13 min read
Five Practical Ways to Improve and Maintain Code Written by Others
360 Quality & Efficiency
360 Quality & Efficiency
Jan 15, 2018 · Fundamentals

Code Health: Reducing Nesting and Complexity

Google’s Code Health team uses bathroom‑posted programming puzzles to illustrate how deep nesting harms readability, and demonstrates that applying guard clauses and refactoring into short, single‑purpose conditionals can separate error handling from core logic, making code easier to understand and maintain.

Nestingcode qualityguard-clauses
0 likes · 3 min read
Code Health: Reducing Nesting and Complexity
Programmer DD
Programmer DD
Dec 28, 2017 · Backend Development

Master IntelliJ IDEA’s Extract Method & Interface Refactoring for Cleaner Java Code

This guide shows how to use IntelliJ IDEA’s Extract Method and Extract Interface features to refactor repetitive Java code, create reusable helper methods like forEachExceptFirst, generate annotated utilities, and cleanly separate contracts from implementations, improving readability and maintainability.

Code ReuseIntelliJ IDEAextract-interface
0 likes · 8 min read
Master IntelliJ IDEA’s Extract Method & Interface Refactoring for Cleaner Java Code
Architecture Digest
Architecture Digest
Dec 13, 2017 · Mobile Development

Practical Code Refactoring Lessons from a Mobile Development Leader

The author, a mobile development team leader, shares a detailed account of a recent iOS codebase refactoring, describing the removal of unused libraries and code, architectural improvements, memory‑leak fixes, and best‑practice guidelines such as avoiding singletons, unnecessary layers, and over‑reliance on third‑party frameworks.

Singletonarchitecturecode cleanup
0 likes · 11 min read
Practical Code Refactoring Lessons from a Mobile Development Leader
Baixing.com Technical Team
Baixing.com Technical Team
Dec 12, 2017 · Mobile Development

Why Composition Beats Inheritance in Android List Refactoring

This article explains how refactoring the Baixing Android app’s list feature from an inheritance-heavy design to a composition-based architecture improves modularity, reduces coupling, and eases future extensions by applying OOP principles such as dependency inversion and component interfaces.

Component ArchitectureComposition over InheritanceDependency Inversion
0 likes · 11 min read
Why Composition Beats Inheritance in Android List Refactoring
Architecture Digest
Architecture Digest
Jul 31, 2017 · Fundamentals

Applying the Observer Pattern to Refactor Order Completion Logic

The article explains how introducing the Observer pattern into an order‑completion module improves code readability, separates responsibilities, and enhances extensibility by turning post‑order actions into independent observers that react to a single subject’s state change.

Javaobserver patternorder processing
0 likes · 4 min read
Applying the Observer Pattern to Refactor Order Completion Logic
Architecture Digest
Architecture Digest
Jul 26, 2017 · Fundamentals

11 Tips for Writing Clear and Readable Code

This article presents eleven practical tips for writing clear, readable code, covering short methods, single-purpose variables, descriptive naming, proximity of declarations, avoiding magic numbers, respecting language idioms, following conventions, steering clear of premature optimization, refactoring after testing, and using patterns wisely.

clean codecode readabilityprogramming best practices
0 likes · 9 min read
11 Tips for Writing Clear and Readable Code
21CTO
21CTO
Jul 8, 2017 · Fundamentals

What Does Writing 1 Million Lines of Code Really Feel Like?

A humorous yet insightful look at the myths of massive codebases, featuring developer anecdotes, realistic productivity calculations, and practical advice on prioritizing code quality, solid fundamentals, and modern tooling over sheer line count.

best practicescode qualitycoding productivity
0 likes · 7 min read
What Does Writing 1 Million Lines of Code Really Feel Like?
21CTO
21CTO
Jun 25, 2017 · Fundamentals

Why Refactoring Matters: A Practical Guide to Cleaner Code

This article explains why refactoring is essential for maintaining legacy systems, defines refactoring, outlines when to start and stop, describes the step‑by‑step process, discusses code smells and techniques, and offers resources for mastering clean, maintainable software.

Software Maintenanceclean codecode quality
0 likes · 13 min read
Why Refactoring Matters: A Practical Guide to Cleaner Code
Architecture Digest
Architecture Digest
Jun 25, 2017 · Fundamentals

Why and How to Refactor Code: Principles, Process, and Best Practices

The article explains why refactoring is essential for maintaining and evolving legacy code, defines refactoring, outlines when to start and stop, lists prerequisites, describes a step‑by‑step process with testing and version control, and connects refactoring to design principles and large‑scale systems.

clean codecode qualityrefactoring
0 likes · 13 min read
Why and How to Refactor Code: Principles, Process, and Best Practices
21CTO
21CTO
Jun 5, 2017 · Frontend Development

How Classic Writing Rules Can Sharpen Your JavaScript Code Style

This article adapts William Strunk Jr.'s timeless seven writing principles to JavaScript development, showing how functions that do one thing, minimal code, active voice, logical grouping, avoiding spaghetti, feature‑based file organization, and true‑value naming can produce cleaner, more maintainable front‑end code.

Code styleFunctional Programmingbest practices
0 likes · 16 min read
How Classic Writing Rules Can Sharpen Your JavaScript Code Style
Hujiang Technology
Hujiang Technology
Jun 2, 2017 · Backend Development

Understanding the Origin, Evolution, and Practical Limits of Microservices in Application Architecture

The article examines why a large‑scale platform refactoring presents an opportunity to redesign services, traces the conceptual roots of microservices through influential software‑engineering masters and methodologies such as DDD and SOA, and argues that microservices are an evolutionary, not silver‑bullet, solution that must be applied with careful strategic and tactical analysis.

Microservicesrefactoringsoftware architecture
0 likes · 16 min read
Understanding the Origin, Evolution, and Practical Limits of Microservices in Application Architecture
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 31, 2017 · R&D Management

12 Essential Rules for Successful Architecture Refactoring (Full Guide)

This comprehensive guide presents Uber engineering leader Raffi Krikorian's twelve practical rules for planning, executing, and managing architecture refactoring, covering purpose definition, incremental approaches, data handling, technical debt, team readiness, and non‑technical influences.

architecturerefactoringsoftware engineering
0 likes · 13 min read
12 Essential Rules for Successful Architecture Refactoring (Full Guide)
21CTO
21CTO
Apr 10, 2017 · Fundamentals

When Are Code Comments Truly Necessary? A Deep Dive into Clean Code Practices

This article examines the role of comments in source code, argues that well‑written, transparent code can often eliminate the need for comments, outlines four levels of code quality, provides concrete refactoring examples, and shares practical clean‑code guidelines such as avoiding magic numbers, reducing parameters, and using contract‑style preconditions.

best practicesclean codecode comments
0 likes · 9 min read
When Are Code Comments Truly Necessary? A Deep Dive into Clean Code Practices
Architecture Digest
Architecture Digest
Mar 27, 2017 · Fundamentals

Why Software Architectures Decay and How to Mitigate It

The article explains how long‑running software projects inevitably suffer architectural decay due to growing codebases, slower builds, and team turnover, and presents practical strategies such as environment upgrades, staged and distributed builds, modular isolation, and platform‑plus‑app designs to keep systems sustainable.

Build Optimizationarchitectural decaymodularization
0 likes · 23 min read
Why Software Architectures Decay and How to Mitigate It
Architecture Digest
Architecture Digest
Feb 19, 2017 · Fundamentals

Why Software Architectures Decay Over Time and How to Mitigate It

This article examines why long‑running software projects experience architectural decay, the limitations of new frameworks, and presents practical solutions such as environment upgrades, phased and distributed builds, refactoring into isolated components, and adopting modular, loosely‑coupled platform‑plus‑application designs to sustain development productivity.

Build OptimizationContinuous Integrationarchitecture
0 likes · 22 min read
Why Software Architectures Decay Over Time and How to Mitigate It
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 25, 2017 · Fundamentals

Why Software Architectures Decay Over Time and How to Combat It

The article examines why long‑running software projects inevitably suffer architectural decay, explains how growth in code, team size, and build complexity erodes productivity, and presents practical strategies—including environment upgrades, phased and distributed builds, component isolation, and adopting new technologies—to slow or reverse the decay.

Build Optimizationproject scalingrefactoring
0 likes · 23 min read
Why Software Architectures Decay Over Time and How to Combat It
Meituan Technology Team
Meituan Technology Team
Jan 19, 2017 · Fundamentals

Clean Code Practices for Object‑Oriented Development

Clean code for object‑oriented development means writing readable, self‑describing, maintainable software by applying principles such as single responsibility, clear naming, small methods, composition over inheritance, regular code reviews, refactoring, static analysis, and learning from open‑source, ensuring simplicity and collaborative excellence.

Javaclean codecode review
0 likes · 20 min read
Clean Code Practices for Object‑Oriented Development
360 Quality & Efficiency
360 Quality & Efficiency
Sep 20, 2016 · Fundamentals

Should You Add Comments to Your Code? – Insights from Refactoring

This discussion post examines whether code should be commented, citing the book *Refactoring* and emphasizing that needing comments often signals the need for refactoring, while good variable names can serve as implicit documentation, and stresses the importance of clear interface comments.

best practicescode commentscoding standards
0 likes · 2 min read
Should You Add Comments to Your Code? – Insights from Refactoring
Architecture Digest
Architecture Digest
Sep 2, 2016 · Fundamentals

Programming Philosophy: Writing Elegant, Modular, Readable, and Robust Code

The article presents a comprehensive programming philosophy that emphasizes repeatedly refining code, writing elegant, modular, readable, and simple programs, handling errors and null pointers robustly, and avoiding over‑engineering, offering practical guidelines applicable to any software development language.

Error handlingNull Safetyrefactoring
0 likes · 41 min read
Programming Philosophy: Writing Elegant, Modular, Readable, and Robust Code
Qunar Tech Salon
Qunar Tech Salon
Aug 11, 2016 · Mobile Development

Refactoring Qunar's Hotel Page with React Native: Challenges, Solutions, and Lessons Learned

This article recounts the Qunar hotel team's experience refactoring a hotel page using React Native, detailing the initial native‑mindset pitfalls, robustness and animation issues, and how adopting a more React‑centric architecture with Redux, connect, and native animation APIs dramatically improved performance, maintainability, and developer experience.

Mobile DevelopmentReact NativeRedux
0 likes · 18 min read
Refactoring Qunar's Hotel Page with React Native: Challenges, Solutions, and Lessons Learned
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Jul 13, 2016 · Frontend Development

Master Mobile Front-End Refactoring: Essential CSS Techniques & Tips

This tutorial series revisits mobile front‑end refactoring, summarizing key techniques such as viewport configuration, CSS3 selectors, pseudo‑elements, responsive units (%, rem, vw, vh), Flexbox layouts, retina‑aware 1px borders, fixed positioning challenges, image placeholder strategies, centering methods, equal‑width distribution, and essential CSS3 animations.

mobilerefactoringresponsive-design
0 likes · 9 min read
Master Mobile Front-End Refactoring: Essential CSS Techniques & Tips
21CTO
21CTO
Jun 11, 2016 · Fundamentals

Why Technical Debt Accumulates and How to Tackle It Effectively

The article shares a veteran IT professional’s insights on how technical debt forms, the risks it brings, various repayment strategies, and practical ways to prevent debt crises, emphasizing continuous management and disciplined engineering practices.

Risk ManagementSoftware Maintenancerefactoring
0 likes · 12 min read
Why Technical Debt Accumulates and How to Tackle It Effectively
Architecture Digest
Architecture Digest
Jun 6, 2016 · Backend Development

Refactoring a 3000‑Line C# Factory Class into a Concise 15‑Line Implementation

The article recounts how the author transformed a massive, repetitive three‑tier factory class in a C# data‑center management system into a clean, reflection‑based solution of just a few lines, while sharing practical refactoring lessons, pitfalls of code generators, and advice on unit‑testing and architecture design.

C#Unit Testingcode generation
0 likes · 17 min read
Refactoring a 3000‑Line C# Factory Class into a Concise 15‑Line Implementation
DevOps
DevOps
May 30, 2016 · Fundamentals

Essential Skills Every Programmer Should Master

The article outlines eight crucial abilities for developers—including computational thinking, problem‑location, effective searching, IDE mastery, refactoring, unit testing, version‑control proficiency, and automated build—to bridge the gap between complex human requirements and the computer's simple instruction set.

IDEprogrammingrefactoring
0 likes · 7 min read
Essential Skills Every Programmer Should Master
Qunar Tech Salon
Qunar Tech Salon
May 25, 2016 · R&D Management

Effective Communication Strategies for Architecture Refactoring Projects

The article explains how to successfully launch and drive large‑scale architecture refactoring by translating technical jargon into plain language, using data‑driven arguments, empathizing with stakeholders, and employing structured escalation and win‑win negotiation tactics to align cross‑functional teams.

R&D Managementarchitecturecommunication
0 likes · 9 min read
Effective Communication Strategies for Architecture Refactoring Projects
Qunar Tech Salon
Qunar Tech Salon
May 24, 2016 · Backend Development

Lessons from Three System Architecture Refactorings: Balancing Business Continuity and Technical Improvement

The article shares practical experiences from refactoring three backend systems—M, S, and X—highlighting the challenges of keeping business running while redesigning architecture, the concrete solutions applied, measurable outcomes such as increased release frequency and higher availability, and key lessons on prioritizing problems and avoiding over‑refactoring.

System Designarchitecturerefactoring
0 likes · 7 min read
Lessons from Three System Architecture Refactorings: Balancing Business Continuity and Technical Improvement
Architect
Architect
May 15, 2016 · R&D Management

Strategic Phased Approach to System Architecture Refactoring

The article outlines how to effectively tackle extensive architecture refactoring by prioritizing issues, classifying them, and implementing a phased strategy that focuses limited resources on specific problem categories to achieve clear, incremental results and maintain team morale.

System Designphased implementationprioritization
0 likes · 9 min read
Strategic Phased Approach to System Architecture Refactoring
21CTO
21CTO
May 13, 2016 · Backend Development

How to Refactor a Live Backend System Without Stopping the Business

The article shares practical experiences and lessons learned from three large‑scale backend architecture refactorings, explaining why doing business‑critical changes while keeping services online is the toughest challenge and how to identify and solve the most critical problems first.

High Availabilitybackendrefactoring
0 likes · 8 min read
How to Refactor a Live Backend System Without Stopping the Business
Architecture Digest
Architecture Digest
Apr 21, 2016 · Backend Development

Evolution and Refactoring of Autohome Mobile Backend Architecture

The article chronicles Autohome's mobile backend transformation from a monolithic ALL‑IN‑ONE design to a modular, high‑availability microservice architecture, detailing the challenges of traffic surge, resource coupling, and rapid releases, and describing the adopted solutions such as service decomposition, stateless design, Java migration, RPC framework, asynchronous components, and comprehensive monitoring and tracing.

MicroservicesMonitoringmobile
0 likes · 11 min read
Evolution and Refactoring of Autohome Mobile Backend Architecture
Qunar Tech Salon
Qunar Tech Salon
Mar 27, 2016 · Backend Development

Understanding Architecture Corruption and How to Mitigate It

The article examines why software architectures inevitably degrade over time in long‑running projects, analyzes the stages of decay, and presents practical strategies—including environment upgrades, phased and distributed builds, component isolation, and platform‑plus‑app designs—to keep systems maintainable and performant.

Build OptimizationContinuous Integrationarchitecture
0 likes · 23 min read
Understanding Architecture Corruption and How to Mitigate It
21CTO
21CTO
Mar 10, 2016 · Fundamentals

How to Write Clear, Maintainable Functions: Naming, Parameters, and Structure

This article explains practical techniques for writing high‑quality functions, covering consistent naming conventions, descriptive function names, optimal parameter handling, clean function bodies, reduced nesting, and other best‑practice tips to improve readability and testability.

Naming Conventionsbest practicescode readability
0 likes · 13 min read
How to Write Clear, Maintainable Functions: Naming, Parameters, and Structure
21CTO
21CTO
Mar 1, 2016 · Fundamentals

Why Bad Code Survives and How Refactoring Can Save Your Projects

The article examines why developers often produce low‑quality, hard‑to‑maintain code, outlines common bad‑code patterns, discusses the limited benefits and high costs of refactoring, and offers practical advice for writing better, more maintainable software.

bad code patternscode qualitymaintainability
0 likes · 12 min read
Why Bad Code Survives and How Refactoring Can Save Your Projects
21CTO
21CTO
Feb 23, 2016 · Fundamentals

Why Writing Less Code Makes You a Better Developer

The article argues that while writing code is essential, the true goal of developers is to minimize code through thoughtful design, using tools that reduce errors, and continuously refactoring to keep code clear, maintainable, and a harmless by‑product of solving problems.

code minimizationcode qualitydevelopment practices
0 likes · 4 min read
Why Writing Less Code Makes You a Better Developer
21CTO
21CTO
Feb 4, 2016 · Fundamentals

12 Essential Rules for Successful Architecture Refactoring by Uber’s Raffi Krikorian

This article presents Uber engineering leader Raffi Krikorian’s twelve practical rules for planning, executing, and validating architecture refactoring, covering purpose definition, incremental delivery, data handling, technical debt, technology choices, pressure management, business alignment, non‑technical factors, code quality, and team readiness.

best practicesengineering managementincremental development
0 likes · 13 min read
12 Essential Rules for Successful Architecture Refactoring by Uber’s Raffi Krikorian
21CTO
21CTO
Jan 14, 2016 · R&D Management

Why Software Architectures Decay Over Time and How to Fight It

The article examines why long‑running software projects inevitably see their architectures degrade, explores the stages of decay, and presents practical strategies—such as environment upgrades, phased and distributed builds, tooling, modular refactoring, and process isolation—to mitigate the problem.

Build Optimizationproject scalingrefactoring
0 likes · 24 min read
Why Software Architectures Decay Over Time and How to Fight It
High Availability Architecture
High Availability Architecture
Jan 13, 2016 · Fundamentals

Bad Code: Causes, Symptoms, and Refactoring Challenges (Part 1)

This article examines why developers produce low‑quality, hard‑to‑maintain code, describing common anti‑patterns such as unclear intent, unreadable logic, poor organization, and missing abstractions, and discusses the difficulties of refactoring such code, while offering insights into recognizing and improving code quality.

bad codebest practicescode quality
0 likes · 15 min read
Bad Code: Causes, Symptoms, and Refactoring Challenges (Part 1)
Java High-Performance Architecture
Java High-Performance Architecture
Jan 12, 2016 · Backend Development

Refactoring a Legacy Transaction System to Java: Strategies and Process

Facing high maintenance costs, complex business demands, and costly Microsoft tech, a company migrated its five‑year‑old transaction platform to Java, employing phased refactoring, comparative testing, and traffic‑splitting to ensure correctness, minimal impact, and a smooth, zero‑downtime rollout with centralized configuration and logging.

System DesignTransactionbackend
0 likes · 5 min read
Refactoring a Legacy Transaction System to Java: Strategies and Process
21CTO
21CTO
Dec 22, 2015 · Fundamentals

12 Proven Practices to Dramatically Boost Code Quality

This article outlines twelve practical techniques—including TDD, ATDD, CI, pair programming, code reviews, static analysis, coding standards, automation, refactoring, early demos, user testing, and team cohesion—that collectively raise software quality while reducing bugs and development costs.

AutomationContinuous IntegrationTest‑Driven Development
0 likes · 8 min read
12 Proven Practices to Dramatically Boost Code Quality
Qunar Tech Salon
Qunar Tech Salon
Dec 22, 2015 · Fundamentals

Programming Philosophy: Writing Elegant, Modular, and Readable Code

The article presents a comprehensive philosophy on software development, emphasizing the importance of repeatedly refining code, structuring it elegantly, modularizing with clear functions, avoiding unnecessary comments, and adopting simple, intuitive practices to improve readability and maintainability across any programming language.

Programming Philosophybest practicescode readability
0 likes · 27 min read
Programming Philosophy: Writing Elegant, Modular, and Readable Code
21CTO
21CTO
Nov 21, 2015 · Backend Development

How to Become a Successful Web Architect: Essential Skills & Roadmap

This article outlines the common pitfalls programmers face on the path to web architecture, emphasizes mastering object‑oriented fundamentals, design patterns, and refactoring, and provides a detailed roadmap of the technical, operational, and managerial knowledge required to become a competent web architect.

Backend Developmentcareer developmentdesign patterns
0 likes · 19 min read
How to Become a Successful Web Architect: Essential Skills & Roadmap
ITPUB
ITPUB
Nov 13, 2015 · Backend Development

Eliminate Code Segregation: Writing Cleaner, More Elegant PHP

This article shows how to transform fragmented PHP snippets—such as disjointed loops, scattered timing code, and split error‑code definitions—into cohesive, readable structures using for‑loops, functional helpers, shutdown callbacks, and modern constant arrays, improving both aesthetics and maintainability.

Code styleError handlingPHP
0 likes · 5 min read
Eliminate Code Segregation: Writing Cleaner, More Elegant PHP
21CTO
21CTO
Oct 16, 2015 · Fundamentals

Master Extract Method Refactoring: Simplify Your PHP Code with Real Examples

This article explains the Extract Method refactoring technique, its definition, benefits, and step‑by‑step PHP examples that show how to split a long method into smaller, well‑named methods, improving readability, reusability, and adherence to the Single Responsibility Principle.

code readabilityextract-methodrefactoring
0 likes · 10 min read
Master Extract Method Refactoring: Simplify Your PHP Code with Real Examples
21CTO
21CTO
Oct 6, 2015 · Fundamentals

How to Tame Legacy Code: Proven Strategies for Effective Cleanup

This guide walks you through practical steps for assessing, testing, version‑controlling, incrementally refactoring, and simplifying messy legacy code so you can safely improve maintainability without introducing new bugs.

Legacy CodeVersion Controlcode cleanup
0 likes · 14 min read
How to Tame Legacy Code: Proven Strategies for Effective Cleanup
MaGe Linux Operations
MaGe Linux Operations
Aug 21, 2015 · Fundamentals

Why Good Architecture Should Be Business‑Independent: Real‑World Refactoring Insights

In this talk, senior architect Neeke shares practical experiences and lessons on software architecture and refactoring, using bridge and building analogies to illustrate how business‑agnostic design, careful analysis of existing support points, and incremental restructuring can transform fragile systems into robust, maintainable solutions.

System Designbusiness independencerefactoring
0 likes · 9 min read
Why Good Architecture Should Be Business‑Independent: Real‑World Refactoring Insights
21CTO
21CTO
Aug 17, 2015 · R&D Management

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

The article examines why software architectures inevitably degrade in long‑running projects, explains the stages of decay, and presents practical strategies—such as upgrading environments, phased and distributed builds, component isolation, and platform‑plus‑app designs—to keep systems maintainable and performant.

codebase decaymodularizationrefactoring
0 likes · 24 min read
Why Do Software Architectures Decay Over Time and How to Stop It?
MaGe Linux Operations
MaGe Linux Operations
Jun 26, 2015 · Fundamentals

Master Git Undo: Revert, Reset, Rebase, and More

This guide explains common Git undo scenarios—reverting public commits, amending messages, discarding local changes, resetting history, using reflog, branching tricks, interactive rebasing, and stopping file tracking—providing clear commands, underlying principles, and practical tips for safely managing version control mistakes.

GitUNDOVersion Control
0 likes · 15 min read
Master Git Undo: Revert, Reset, Rebase, and More
Architect
Architect
May 12, 2015 · Fundamentals

12 Rules for Successful Architecture Refactoring – Insights from Uber’s Raffi Krikorian

The article presents Uber engineering leader Raffi Krikorian’s twelve practical rules for planning, executing, and managing software architecture refactoring, emphasizing clear purpose, measurable goals, incremental delivery, data‑driven decisions, technical debt control, realistic technology choices, and stakeholder communication.

Data-Drivenincremental deliverymanagement
0 likes · 13 min read
12 Rules for Successful Architecture Refactoring – Insights from Uber’s Raffi Krikorian
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
May 12, 2015 · Industry Insights

How to Avoid the Hype: Practical Rules for Successful Architecture Refactoring

This article offers goal‑oriented, data‑driven advice and checklists for architecture refactoring, emphasizing realistic technology selection, pressure management, business understanding, handling non‑technical influences, code‑quality practices, and team readiness to ensure effective, sustainable redesigns.

architecturebest practiceschecklist
0 likes · 7 min read
How to Avoid the Hype: Practical Rules for Successful Architecture Refactoring
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
May 7, 2015 · Fundamentals

12 Rules for Successful Architecture Refactoring – Insights from Uber’s Engineering Leader

The article presents Uber engineering manager Raffi Krikorian’s twelve practical rules for planning, executing, and evaluating software architecture refactoring, emphasizing clear purpose, measurable goals, incremental delivery, current state assessment, data‑driven decisions, and diligent management of technical debt.

incremental deliveryrefactoringsoftware design
0 likes · 8 min read
12 Rules for Successful Architecture Refactoring – Insights from Uber’s Engineering Leader