Tagged articles

388 articles

Page 4 of 4

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

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.

Object-Orientedclean codecode smells

0 likes · 27 min read

Master Code Refactoring: Principles, Smells, and Practical Techniques

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

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

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.

clean codecode readabilitycoding best practices

0 likes · 11 min read

6 Proven Techniques to Write Clean, Maintainable Code

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

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.

DebuggingEclipseIntelliJ IDEA

0 likes · 9 min read

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

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.

best practicesrefactoringsoftware design

0 likes · 6 min read

Seven Practical Techniques for Writing Testable Code

Big Data Technology & Architecture

Jun 25, 2019 · Fundamentals

Refactoring Nested If‑Else Statements with Design Patterns in Java

This article examines the problems of deeply nested if‑else statements in Java code and demonstrates how to replace them with cleaner alternatives such as the Factory pattern, enums, the Command pattern, and a simple rule engine, improving readability and maintainability.

Command PatternDesign PatternsFactory Pattern

0 likes · 9 min read

Refactoring Nested If‑Else Statements with Design Patterns in Java

Java Backend Technology

Jun 13, 2019 · Backend Development

What Makes Java Code Terrible? 7 Jaw‑Dropping Bad Code Examples Revealed

An eye‑opening roundup of seven notoriously awful Java snippets—from misused StringBuffer and endless nested loops to convoluted Stream pipelines and absurd exception definitions—showcasing why such code is a nightmare, how it hampers readability, and what refactoring strategies can rescue it.

JavaStream APIbad practices

0 likes · 15 min read

What Makes Java Code Terrible? 7 Jaw‑Dropping Bad Code Examples Revealed

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.

BackendMicroservicesSoftware Engineering

0 likes · 8 min read

Refactoring a Core Business System: Lessons Learned and Best Practices

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.

Higher-Order FunctionsMAPPure Functions

0 likes · 22 min read

Functional Programming in JavaScript: Refactoring User List Processing

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

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

Java Captain

Feb 18, 2019 · Fundamentals

How to Refactor Badly Written Code: Principles, Code Smells, and Refactoring Techniques

This article explains the purpose and principles of refactoring, enumerates common code smells, and provides concrete refactoring techniques—including extracting functions, inlining, moving features, reorganizing data, simplifying conditionals and calls—illustrated with Java code examples.

clean codecode smellsrefactoring

0 likes · 22 min read

How to Refactor Badly Written Code: Principles, Code Smells, and Refactoring Techniques

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.

Software Engineeringbest practicescode quality

0 likes · 8 min read

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

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.

Backendconcurrencydistributed-systems

0 likes · 10 min read

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

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

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

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.

Project ManagementSoftware Engineeringcode quality

0 likes · 6 min read

Why Programmers Refactor Code and How to Do It Effectively

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.

Software Engineeringclean codecode style

0 likes · 10 min read

Best Practices for Writing Clean and Maintainable Code

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

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.

Software Engineeringbest practicesclean code

0 likes · 13 min read

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

ITFLY8 Architecture Home

Jul 3, 2018 · Backend Development

Why Three‑Tier Architecture Fails and How Microservices Solve Scaling Challenges

From the basics of three‑tier architecture to the challenges of scaling, this article explains why monolithic designs become problematic, how fine‑grained and coarse‑grained microservices address complexity, and offers practical refactoring steps for high‑concurrency systems.

Microserviceshigh concurrencyrefactoring

0 likes · 6 min read

Why Three‑Tier Architecture Fails and How Microservices Solve Scaling Challenges

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.

Software ArchitectureThree-tierhigh concurrency

0 likes · 7 min read

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

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.

Career DevelopmentSoftware Engineeringcoding practices

0 likes · 9 min read

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

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.

Design PatternsObject-Oriented DesignSoftware Architecture

0 likes · 11 min read

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

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

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

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.

Object-Orientedclean codecode smells

0 likes · 24 min read

How to Eliminate 22 Common Code Smells with Refactoring Techniques

ITFLY8 Architecture Home

Feb 4, 2018 · Fundamentals

Why Refactoring Matters: Boost Code Quality, Speed, and Maintainability

This article explains what refactoring is, why it improves code quality, readability, and development speed, when to apply or avoid it, the typical refactoring workflow, its relationship with design, and how it impacts software performance.

Development Speedcode qualitymaintainability

0 likes · 7 min read

Why Refactoring Matters: Boost Code Quality, Speed, and Maintainability

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.

Career DevelopmentDesign PatternsSoftware Architecture

0 likes · 19 min read

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

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.

Code reviewLegacy CodeSoftware Engineering

0 likes · 13 min read

Five Practical Ways to Improve and Maintain Code Written by Others

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.

Software Engineeringcode qualityguard-clauses

0 likes · 3 min read

Code Health: Reducing Nesting and Complexity

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.

IntelliJ IDEAcode-reuseextract-interface

0 likes · 8 min read

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

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

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

Dec 8, 2017 · Fundamentals

Reflections on Refactoring a Decade‑Old Core Module: Mindset, Techniques, and Design Patterns

The article shares a developer's hard‑won lessons from refactoring a ten‑year‑old core system, emphasizing the crucial role of mindset, careful business‑logic analysis, selective task handling, and the use of design patterns to achieve clean, extensible code.

Design PatternsMindsetcode quality

0 likes · 9 min read

Reflections on Refactoring a Decade‑Old Core Module: Mindset, Techniques, and Design Patterns

Baidu Waimai Technology Team

Aug 22, 2017 · Backend Development

Design and Iterative Refactoring of a Permission Application Workflow on the Do Platform

This article describes the business flow, storage schema, template‑method based code framework, workflow integration, Redis‑based lock mechanism, and two major refactoring iterations that improve the permission‑application approval process for the Do platform.

BackendTemplate Methodmysql

0 likes · 11 min read

Design and Iterative Refactoring of a Permission Application Workflow on the Do Platform

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 PatternSoftware Architecture

0 likes · 4 min read

Applying the Observer Pattern to Refactor Order Completion Logic

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.

Software Engineeringclean codecode readability

0 likes · 9 min read

11 Tips for Writing Clear and Readable Code

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.

Software Engineeringbest practicescode quality

0 likes · 7 min read

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

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.

Technical Debtclean codecode quality

0 likes · 13 min read

Why Refactoring Matters: A Practical Guide to Cleaner Code

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.

Software Engineeringclean codecode quality

0 likes · 13 min read

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

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.

best practicesclean codecode style

0 likes · 16 min read

How Classic Writing Rules Can Sharpen Your JavaScript Code Style

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.

MicroservicesSoftware Architecturerefactoring

0 likes · 16 min read

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

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.

Software EngineeringTechnical Debtarchitecture

0 likes · 13 min read

12 Essential Rules for Successful Architecture Refactoring (Full Guide)

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.

Software Engineeringbest practicesclean code

0 likes · 9 min read

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

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 OptimizationScalabilitySoftware Architecture

0 likes · 23 min read

Why Software Architectures Decay and How to Mitigate It

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 Optimizationarchitecturecontinuous integration

0 likes · 22 min read

Why Software Architectures Decay Over Time and How to Mitigate It

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 OptimizationSoftware ArchitectureTechnical Debt

0 likes · 23 min read

Why Software Architectures Decay Over Time and How to Combat It

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.

Code reviewDesign PatternsJava

0 likes · 20 min read

Clean Code Practices for Object‑Oriented Development

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.

Software Engineeringbest practicescode comments

0 likes · 2 min read

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

Huawei Cloud Developer Alliance

Sep 13, 2016 · Fundamentals

Four Simple Principles to Write High‑Quality Code Every Time

This article identifies why most code remains low‑quality despite many guidelines and presents four practical principles—single abstraction level, minimized indentation, clear expressions, and effective use of helper classes—that dramatically improve a team's coding standards.

best practicesclean codecode quality

0 likes · 5 min read

Four Simple Principles to Write High‑Quality Code Every Time

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 HandlingSoftware Engineeringnull safety

0 likes · 41 min read

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

Tencent IMWeb Frontend Team

Aug 16, 2016 · Frontend Development

How to Automate JavaScript Component Refactoring with jscodeshift

Learn how to use Facebook’s jscodeshift tool to write codemods that automatically rename lifecycle methods in JavaScript components, with step‑by‑step examples, test setup using AVA, and detailed AST traversal logic for precise transformations.

ASTAVAJavaScript

0 likes · 5 min read

How to Automate JavaScript Component Refactoring with jscodeshift

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

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

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.

Software EngineeringTechnical Debtrefactoring

0 likes · 12 min read

Why Technical Debt Accumulates and How to Tackle It Effectively

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.

CCode Generationrefactoring

0 likes · 17 min read

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

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

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 managementSoftware Engineeringarchitecture

0 likes · 9 min read

Effective Communication Strategies for Architecture Refactoring Projects

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.

ScalabilitySystem Designarchitecture

0 likes · 7 min read

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

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.

Backendhigh availabilityrefactoring

0 likes · 8 min read

How to Refactor a Live Backend System Without Stopping the Business

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.

MicroservicesMobileScalability

0 likes · 11 min read

Evolution and Refactoring of Autohome Mobile Backend Architecture

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 OptimizationScalabilityarchitecture

0 likes · 23 min read

Understanding Architecture Corruption and How to Mitigate It

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.

best practicescode readabilityfunction design

0 likes · 13 min read

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

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.

Software Engineeringbad code patternscode quality

0 likes · 12 min read

Why Bad Code Survives and How Refactoring Can Save Your Projects

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.

Software Engineeringcode minimizationcode quality

0 likes · 4 min read

Why Writing Less Code Makes You a Better Developer

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.

Engineering managementTechnical Debtbest practices

0 likes · 13 min read

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

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 OptimizationTechnical Debtproject scaling

0 likes · 24 min read

Why Software Architectures Decay Over Time and How to Fight It

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.

Software Engineeringbad codebest practices

0 likes · 15 min read

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

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.

BackendSystem Designrefactoring

0 likes · 5 min read

Refactoring a Legacy Transaction System to Java: Strategies and Process

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.

AutomationCode reviewcode quality

0 likes · 8 min read

12 Proven Practices to Dramatically Boost Code Quality

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 PhilosophySoftware Engineeringbest practices

0 likes · 27 min read

Programming Philosophy: Writing Elegant, Modular, and Readable Code

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

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.

BackendError HandlingPHP

0 likes · 5 min read

Eliminate Code Segregation: Writing Cleaner, More Elegant PHP

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

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

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.

Software ArchitectureSystem DesignTechnical Debt

0 likes · 9 min read

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

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.

Software ArchitectureTechnical Debtcodebase decay

0 likes · 24 min read

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

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

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-drivenManagementTechnical Debt

0 likes · 13 min read

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

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.

ManagementTechnical Debtarchitecture

0 likes · 7 min read

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

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.

Technical Debtincremental deliveryrefactoring

0 likes · 8 min read

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

Qunar Tech Salon

Mar 2, 2015 · Fundamentals

Understanding Code Complexity Metrics and Using PMD and JavaNCSS to Manage Long Methods and Classes

The article explains how cyclomatic complexity, method and class length, and internal class coupling affect code maintainability, and demonstrates how tools like PMD and JavaNCSS can be configured to detect and refactor overly long or tightly coupled code structures.

JavaNCSScode complexitycode quality

0 likes · 11 min read

Understanding Code Complexity Metrics and Using PMD and JavaNCSS to Manage Long Methods and Classes

Baidu Tech Salon

Nov 27, 2014 · Fundamentals

Why Perfect Code Is a Myth and How to Embrace Pragmatic Refactoring

The article argues that striving for flawless code is futile because most software constantly evolves, and it advocates focusing on correctness, readability, and pragmatic refactoring rather than chasing unattainable perfection.

Software EngineeringTechnical Debtcode quality

0 likes · 8 min read

Why Perfect Code Is a Myth and How to Embrace Pragmatic Refactoring