BestHub
Sign in
Tagged articles

technical debt

212 articles · Page 2 of 3
Ops Development & AI Practice
Ops Development & AI Practice
Feb 10, 2024 · R&D Management

How the Broken Window Effect Undermines Code Quality—and What Teams Can Do About It

Software teams often fall prey to the broken window effect, where a few low‑quality code snippets lower overall standards, increase technical debt, and sap morale; this article examines the phenomenon and outlines practical strategies—clear coding standards, regular reviews, continuous training, and a quality‑focused culture—to counteract it.

R&D Managementbest practicescode quality
0 likes · 4 min read
How the Broken Window Effect Undermines Code Quality—and What Teams Can Do About It
DevOps
DevOps
Feb 3, 2024 · Fundamentals

Understanding Technical Debt: From Birth to Decay of Business Systems

The article examines why every business system accumulates technical debt over time, outlines the stages from initial creation to maintenance decay, analyzes the human and architectural factors that make legacy systems hard to work with, and proposes domain‑modeling and disciplined engineering practices to mitigate and delay that decay.

AnalysisDomain modelingSoftware Engineering
0 likes · 23 min read
Understanding Technical Debt: From Birth to Decay of Business Systems
Efficient Ops
Efficient Ops
Jan 23, 2024 · Operations

Why Building Truly High‑Availability Systems Is Harder Than You Think

The article examines why 2023 saw a surge in major online outages, linking layoffs and cost‑cutting to lost expertise, and explores the entropy and Murphy laws that make perpetual high availability impossible without continuous, systematic investment and cultural change.

High AvailabilitySREsystem reliability
0 likes · 13 min read
Why Building Truly High‑Availability Systems Is Harder Than You Think
DevOps
DevOps
Jan 12, 2024 · Operations

Why Building a Never‑Failing System Is Impossible and How to Pursue Continuous High Availability

The article analyses why truly never‑failing systems cannot exist—citing entropy and Murphy’s laws—examines the organizational and technical obstacles to continuous high availability, and offers practical cultural and engineering practices such as testing, code review, monitoring, and regular system health checks to mitigate risk.

High AvailabilityMurphy's LawOperations
0 likes · 14 min read
Why Building a Never‑Failing System Is Impossible and How to Pursue Continuous High Availability
Tencent Cloud Developer
Tencent Cloud Developer
Jan 10, 2024 · Operations

The Challenges of Building Continuously Available Systems: Entropy, Murphy's Law, and the 'Divine Doctor Paradox'

Building continuously available systems in 2023 is hampered by entropy‑driven technical debt and Murphy’s Law failures, and the “Divine Doctor Paradox” shows that successful availability work goes unnoticed while blame follows any outage, making cultural commitment—not just technology—the essential solution.

High AvailabilityMurphy's LawSRE
0 likes · 14 min read
The Challenges of Building Continuously Available Systems: Entropy, Murphy's Law, and the 'Divine Doctor Paradox'
macrozheng
macrozheng
Dec 21, 2023 · Fundamentals

Keeping Code Clean During Rapid Development: Review and Refactoring Strategies

The article shares practical experiences and advice on maintaining code quality through disciplined code reviews, incremental refactoring, and team-wide coding standards, emphasizing readability and continuous improvement to prevent technical debt and the broken‑window effect in fast‑moving projects.

Code Reviewcode qualityrefactoring
0 likes · 9 min read
Keeping Code Clean During Rapid Development: Review and Refactoring Strategies
Tencent Cloud Developer
Tencent Cloud Developer
Dec 20, 2023 · Fundamentals

Why Business Systems Accumulate Debt and How to Prevent It

Business systems accumulate technical debt as rapid growth, pseudo‑agile practices, unclear requirements, and staff turnover introduce hidden complexity, but systematic domain modeling, thorough analysis, disciplined design, and continuous learning can mitigate decay, keep code maintainable, and sustain developer motivation.

AnalysisDomain modelingProject Management
0 likes · 24 min read
Why Business Systems Accumulate Debt and How to Prevent It
FunTester
FunTester
Nov 27, 2023 · Industry Insights

From Software Debt to Body Debt: Entropy, 5 Whys, and Structured Thinking

The article explores why technical and business debt inevitably grow, using entropy theory, 5‑why analysis, Conway's law, and communication complexity, then draws parallels to personal health, offering structured thinking methods to identify, prioritize, and eliminate hidden liabilities in both software projects and everyday life.

5 why analysisSoftware Engineeringbusiness communication
0 likes · 20 min read
From Software Debt to Body Debt: Entropy, 5 Whys, and Structured Thinking
Tencent Cloud Developer
Tencent Cloud Developer
Nov 21, 2023 · Fundamentals

Understanding Business Debt and Physical Debt: Structured Thinking and Management

The article argues that both business and personal health debts inevitably accumulate like entropy, but can be managed through structured thinking—identifying, categorizing, prioritizing, and continuously monitoring and feedback‑driven actions such as mindfulness, exercise, and disciplined system maintenance—to reduce complexity and sustain growth.

Conway's LawHealth Managemententropy
0 likes · 18 min read
Understanding Business Debt and Physical Debt: Structured Thinking and Management
Architecture and Beyond
Architecture and Beyond
Nov 18, 2023 · R&D Management

Understanding Cognitive, Communication, and Abnormal Costs in Software Development

The article examines how software development teams incur hidden cognitive, communication, and abnormal costs, explains their sources such as memory load and technical debt, and proposes practical strategies—including talent selection, shared standards, and incident prevention—to reduce these costs and improve overall R&D efficiency.

R&D Managementcognitive costcommunication cost
0 likes · 12 min read
Understanding Cognitive, Communication, and Abnormal Costs in Software Development
Architect
Architect
Nov 15, 2023 · Backend Development

How DDD and Architecture Mapping Reshaped Tencent Video’s System – A Quantitative Case Study

This article analyses how Domain‑Driven Design and a systematic architecture‑mapping process were applied to the Tencent Video “together‑watch” service, presenting concrete domain models, architectural decisions, refactoring steps, and quantitative evaluations—including code‑size reduction, performance gains, and cost savings—while preserving the full analytical reasoning behind each choice.

DDDDomain modelingMicroservices
0 likes · 18 min read
How DDD and Architecture Mapping Reshaped Tencent Video’s System – A Quantitative Case Study
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 7, 2023 · Frontend Development

How to Turn Technical Debt into Growth: Refactoring Lessons from Alibaba Cloud

This article shares a developer’s three‑year journey on Alibaba Cloud’s platform, exploring the nature of technical debt, categorizing its causes, and illustrating how micro‑refactorings and configuration‑driven upgrades can steadily improve code quality, accelerate feature delivery, and align engineering with business goals.

Configurationfrontend developmentrefactoring
0 likes · 10 min read
How to Turn Technical Debt into Growth: Refactoring Lessons from Alibaba Cloud
FunTester
FunTester
Nov 1, 2023 · Fundamentals

Understanding and Managing Technical Debt in Software Development

This article explains what technical debt is, its harmful effects, common scenarios that generate it, common misconceptions, and practical strategies for managing and repaying technical debt to keep software projects maintainable and cost‑effective.

Software Engineeringcode qualityrefactoring
0 likes · 25 min read
Understanding and Managing Technical Debt in Software Development
Tencent Cloud Developer
Tencent Cloud Developer
Oct 30, 2023 · Fundamentals

Understanding and Managing Technical Debt in Software Development

Technical debt—ranging from low‑level design flaws and inadequate testing to strategic shortcuts and evolving third‑party dependencies—accumulates when urgent product demands bypass best practices, leading to higher costs, slower delivery, and poorer quality, so teams must make debt visible, enforce strong completion criteria, and allocate regular sprint capacity to prioritize, refactor, and repay high‑interest debt while recognizing when legacy code can be retired.

refactoringrisk managementtechnical debt
0 likes · 25 min read
Understanding and Managing Technical Debt in Software Development
DevOps
DevOps
Oct 22, 2023 · R&D Management

Improving Code Quality and Development Efficiency: Strategies for Time Pressure, Requirement Changes, Motivation, Collaboration, Technical Debt, Automation, and Feedback

This article outlines practical strategies for enhancing code quality and development efficiency, addressing challenges such as time pressure, frequent requirement changes, lack of self‑motivation, poor team communication, technical debt, insufficient automation, and feedback mechanisms, and includes a real‑world case study and certification promotion.

DevOpsTeam Collaborationcode quality
0 likes · 13 min read
Improving Code Quality and Development Efficiency: Strategies for Time Pressure, Requirement Changes, Motivation, Collaboration, Technical Debt, Automation, and Feedback
21CTO
21CTO
Aug 11, 2023 · Backend Development

How Layered Architecture Keeps a 28K‑File Python Monolith Manageable

This article explains how a massive Python codebase with over 27,000 modules is organized using a layered architecture, enforced with Import Linter, to reduce complexity, track technical debt, and enable independent development across clients and territories.

Code OrganizationPythonimport-linter
0 likes · 14 min read
How Layered Architecture Keeps a 28K‑File Python Monolith Manageable
Tencent Cloud Developer
Tencent Cloud Developer
Jul 25, 2023 · Fundamentals

From Code Design to Refactoring: Improving Code Quality

The article shows how high‑quality code emerges from solid design and disciplined refactoring, using an image‑optimization tool case study to illustrate breaking tangled if‑else logic into Strategy and Template Method patterns, applying SOLID principles, six quality pillars, and managing technical debt and code smells.

SOLIDrefactoringtechnical debt
0 likes · 30 min read
From Code Design to Refactoring: Improving Code Quality
Tencent Cloud Developer
Tencent Cloud Developer
Jul 10, 2023 · Fundamentals

Understanding Technical Debt: Causes, Impacts, and Mitigation Strategies

Technical debt, the hidden cost of shortcuts across code, business, and team practices, grows from evolving technology, rapid business changes, and weak standards, but can be managed through disciplined analysis, standardized design, iterative planning, metric‑driven reviews, dedicated resources, and a professional, top‑down mindset.

development processrisk managementteam culture
0 likes · 15 min read
Understanding Technical Debt: Causes, Impacts, and Mitigation Strategies
DevOps
DevOps
May 30, 2023 · R&D Management

Understanding and Managing Technical Debt: Quadrants, Types, and Practical Steps

This article explains the concept of technical debt, its four-quadrant model, various debt types, and presents a six‑step process—including identification, visualization, prioritization, planning, execution, and review—to effectively manage and reduce technical debt for higher software quality and delivery speed.

DevOpsSoftware Engineeringsoftware quality
0 likes · 7 min read
Understanding and Managing Technical Debt: Quadrants, Types, and Practical Steps
DevOps
DevOps
May 18, 2023 · Fundamentals

Understanding Technical Debt: Definitions, Types, Impacts, and Management Strategies

This article explains the concept of technical debt, its origins, various classifications, the economic analogy with financial debt, the risks of ignoring it, and practical approaches for identifying, prioritizing, and repaying it through regular refactoring and disciplined engineering practices.

DevOpsSoftware Engineeringproduct management
0 likes · 22 min read
Understanding Technical Debt: Definitions, Types, Impacts, and Management Strategies
DevOps
DevOps
Apr 28, 2023 · Fundamentals

Understanding Software Quality: Internal vs External, Speed Trade‑offs, and Economic Impact

This article explores the concept of software quality, distinguishing internal and external quality, examining their relationship with development speed, technical debt, and economics, and discusses models, product stages, customer perspectives, and the influence of digital transformation on quality assurance.

DevOpsSoftware Engineeringproduct management
0 likes · 20 min read
Understanding Software Quality: Internal vs External, Speed Trade‑offs, and Economic Impact
Top Architect
Top Architect
Mar 15, 2023 · Fundamentals

Understanding Software Architecture: Concepts, Layers, Levels, Evolution, and Common Pitfalls

This article explains the definition and essence of software architecture, outlines its layers and classifications, describes architectural levels and the evolution from monolithic to micro‑service designs, and discusses how to evaluate architectural rationality while highlighting typical misconceptions and best‑practice guidelines.

System Designarchitecture patternsscalability
0 likes · 23 min read
Understanding Software Architecture: Concepts, Layers, Levels, Evolution, and Common Pitfalls
Smart Era Software Development
Smart Era Software Development
Feb 6, 2023 · R&D Management

Battling Software Scale and Complexity: Rescue, Cure, and Maintenance (Part 1)

The article examines why software development, despite modern tooling, still behaves like a handicraft that collapses under scale, explains essential versus accidental complexity, illustrates common sources of random complexity with real cases, and proposes a three‑step strategy—rescue, cure, and maintenance—to control growth.

R&D Managementaccidental complexityessential complexity
0 likes · 15 min read
Battling Software Scale and Complexity: Rescue, Cure, and Maintenance (Part 1)
Programmer DD
Programmer DD
Nov 15, 2022 · Backend Development

Why Elon Musk’s Twitter App Critique Missed the Real Performance Issues

Elon Musk’s public criticism of the Twitter app’s RPC usage sparked a heated response from Twitter’s engineers, who clarified that the app’s slowness stems from unused features, accumulated technical debt, and network latency rather than the alleged batch RPC calls.

AndroidTwittertechnical debt
0 likes · 4 min read
Why Elon Musk’s Twitter App Critique Missed the Real Performance Issues
DevOps
DevOps
Oct 19, 2022 · Product Management

Defining What Flows Through a Software Value Stream: The Four Types of Work Items

The article explains how to apply lean manufacturing principles to software delivery by identifying four distinct work‑item categories that flow through a software value stream—features and defect fixes, security/compliance tasks, enabler work, and technical‑debt reduction—enabling organizations to measure productivity and locate bottlenecks.

DevOpsLean Manufacturingproduct management
0 likes · 11 min read
Defining What Flows Through a Software Value Stream: The Four Types of Work Items
DaTaobao Tech
DaTaobao Tech
Aug 23, 2022 · Frontend Development

The Evolution and Redesign of Taobao PC Homepage

In May 2022 Taobao unveiled a completely rebuilt PC homepage, replacing a decade‑old, error‑prone codebase that had lost users after the “ALL‑IN‑Wireless” shift, with a unified front‑end platform engineered by veteran developer Yongba that adds modern release controls, cross‑device consistency, and a roadmap for further feature upgrades.

PC FrontendTaobaohomepage redesign
0 likes · 13 min read
The Evolution and Redesign of Taobao PC Homepage
DevOps
DevOps
Jul 29, 2022 · R&D Management

Strategies for Managing Large‑Scale Legacy Systems at Different Scales

The article examines the typical traits of massive legacy codebases, outlines the technical debt they generate, and proposes practical strategies—from design‑pattern mastery and daily code reviews for small teams to metrics‑driven debt tracking, agile practices, and clean‑architecture principles for million‑line and ten‑million‑line systems—aimed at safely evolving such systems while maintaining team stability.

Legacy SystemsMicroservicessoftware architecture
0 likes · 15 min read
Strategies for Managing Large‑Scale Legacy Systems at Different Scales
21CTO
21CTO
Jul 16, 2022 · Fundamentals

How an Investor’s Mindset Can Transform Your Software Engineering Decisions

The article explains how adopting an investor’s perspective—focusing on return timing, opportunity cost, and disciplined cost‑benefit analysis—helps engineers choose projects, evaluate migrations, and make smarter technical decisions that maximize value and reduce risk.

Cost-Benefit AnalysisMigrationProject Management
0 likes · 11 min read
How an Investor’s Mindset Can Transform Your Software Engineering Decisions
Software Development Quality
Software Development Quality
Jul 9, 2022 · R&D Management

How to Minimize Technical Debt and Boost Delivery Efficiency

This guide defines technical debt, outlines its classification into vulnerabilities, bugs, and code smells, and presents clear objectives, principles, standards, evaluation rules, recommended practices, and metrics to visualize, assess, and systematically reduce debt, thereby improving project delivery efficiency.

Code ReviewDevOpsSonarQube
0 likes · 5 min read
How to Minimize Technical Debt and Boost Delivery Efficiency
macrozheng
macrozheng
Jul 8, 2022 · Fundamentals

Why Bad Code Thrives: Lessons from the Trenches

The article reflects on how rushed schedules, misguided management tools, inexperienced developers, and ego‑driven customizations create and perpetuate low‑quality code, urging developers to recognize technical debt, avoid reckless refactoring, and seek realistic project timelines and proper team practices.

Software Engineeringcode qualitydevelopment practices
0 likes · 8 min read
Why Bad Code Thrives: Lessons from the Trenches
Architecture and Beyond
Architecture and Beyond
Jul 2, 2022 · R&D Management

Five Key Steps to Build a High‑Performance Development Team

This article outlines five essential steps—defining the right goals, optimizing processes, boosting team effectiveness, strengthening individual capabilities, and implementing sensible metrics—to create a high‑performance software development team that delivers quality quickly and aligns with business value.

Process OptimizationR&D Efficiencyteam management
0 likes · 14 min read
Five Key Steps to Build a High‑Performance Development Team
DevOps Cloud Academy
DevOps Cloud Academy
Jul 1, 2022 · Operations

How DevOps Can Help Reduce Technical Debt

This article explains what technical debt is, why it arises, and how adopting DevOps practices such as cross‑functional teams, automation, infrastructure‑as‑code, containerization, and API‑centric design can identify, track, and repay technical debt to improve system reliability and agility.

AutomationDevOpsInfrastructure as Code
0 likes · 9 min read
How DevOps Can Help Reduce Technical Debt
Programmer DD
Programmer DD
May 24, 2022 · Frontend Development

How GOV.UK Boosted Performance by Dropping jQuery: 31% JS Size Reduction

Matt Hobbs, the front‑end lead at GOV.UK, removed jQuery from 13 applications, cutting JavaScript size by up to 49 % and improving key performance metrics such as processing time, First CPU Idle, and long‑task duration, even under poor network conditions.

FrontendjQuery removalperformance
0 likes · 3 min read
How GOV.UK Boosted Performance by Dropping jQuery: 31% JS Size Reduction
IT Services Circle
IT Services Circle
Mar 27, 2022 · Fundamentals

Understanding Bad Code: Causes, Characteristics, Risks, and Solutions

This article examines why developers produce low‑quality code, describes typical symptoms such as unreadability and excessive nesting, outlines the long‑term costs and risks of bad code, and presents expert‑recommended practices—including code reviews, design documentation, technical debt repayment, and disciplined development processes—to improve code quality.

Code ReviewSoftware Engineeringbad code
0 likes · 12 min read
Understanding Bad Code: Causes, Characteristics, Risks, and Solutions
Architects' Tech Alliance
Architects' Tech Alliance
Mar 16, 2022 · Fundamentals

Comprehensive Overview of Software Architecture: Concepts, Layers, Levels, Evolution, and Best Practices

This article provides an extensive introduction to software architecture, covering its definition, essential concepts such as systems, subsystems, modules, components, and frameworks, various architectural layers and classifications, architectural levels, strategic versus tactical design, evolution from monoliths to micro‑services, common pitfalls, measurement criteria, and recommended learning resources.

MicroservicesSystem Designapplication architecture
0 likes · 21 min read
Comprehensive Overview of Software Architecture: Concepts, Layers, Levels, Evolution, and Best Practices
DevOps
DevOps
Mar 8, 2022 · Fundamentals

Understanding Technical Debt: Classification, Impact, and Mitigation Strategies

The article explains the origins and four quadrants of technical debt, outlines its detrimental effects on software quality and maintainability, and offers practical approaches—including daily debt management, clear technical standards, continuous technology monitoring, visualization, and sustained investment—to identify, prioritize, and reduce technical debt in development teams.

code qualityrisk managementsoftware architecture
0 likes · 10 min read
Understanding Technical Debt: Classification, Impact, and Mitigation Strategies
21CTO
21CTO
Mar 7, 2022 · Fundamentals

10 Must‑Have JetBrains IDE Extensions to Tackle Technical Debt

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

IDE ExtensionsJetBrainscode quality
0 likes · 7 min read
10 Must‑Have JetBrains IDE Extensions to Tackle Technical Debt
Alibaba Terminal Technology
Alibaba Terminal Technology
Feb 21, 2022 · Frontend Development

How a Frontend Architect Became a ‘Chef’ to Serve Teams and Tame Technical Debt

This article follows a front‑end architect who treats architecture like cooking, writes massive amounts of code, builds a Node‑based framework to bridge front‑end and back‑end, tackles legacy system debt, and shares a philosophy that blends technical rigor with service‑oriented mindset.

Frontend ArchitectureSoftware Designdeveloper experience
0 likes · 9 min read
How a Frontend Architect Became a ‘Chef’ to Serve Teams and Tame Technical Debt
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 20, 2022 · Fundamentals

Why Technical Debt Grows: The Hidden Impact of Communication and Modeling

The article explains that technical debt stems not from clumsy coding but from poor communication and inadequate domain modeling, leading to fragmented abstractions, excessive boolean flags, and ultimately software bankruptcy, and suggests collaborative, model‑driven practices to reduce it.

Domain modelingSoftware EngineeringTeam Collaboration
0 likes · 12 min read
Why Technical Debt Grows: The Hidden Impact of Communication and Modeling
DevOps
DevOps
Dec 3, 2021 · Fundamentals

Why High Software Quality Actually Reduces Production Cost

Software quality is often seen as a trade‑off with cost, but Martin Fowler argues that higher internal quality—clean architecture, modular code, and reduced cruft—lowers future development expenses, speeds feature delivery, and ultimately makes high‑quality software cheaper to produce despite short‑term effort.

cost reductioninternal qualitysoftware development
0 likes · 14 min read
Why High Software Quality Actually Reduces Production Cost
DevOps
DevOps
Nov 24, 2021 · Fundamentals

How to Lead Your Team’s Technical Debt Management

This article explains what technical debt is, why it matters, and provides practical guidance on avoiding blame, discussing risks, prioritizing work with techniques like delay cost and ICE/RICE, and implementing concrete strategies to allocate effort and reduce debt in software projects.

Software EngineeringTeam Collaborationprioritization
0 likes · 12 min read
How to Lead Your Team’s Technical Debt Management
dbaplus Community
dbaplus Community
Nov 14, 2021 · Operations

How to Boost Service Reliability: SRE Basics and Tackling Technical Debt

This article explains the fundamentals of Site Reliability Engineering, outlines a complete SRE workflow from prevention to post‑mortem, details key availability metrics and golden indicators, examines how technical debt arises and can be mitigated, and describes the tooling and practices needed to keep large‑scale services healthy.

MonitoringSREservice reliability
0 likes · 18 min read
How to Boost Service Reliability: SRE Basics and Tackling Technical Debt
HaoDF Tech Team
HaoDF Tech Team
Oct 8, 2021 · Operations

Understanding SRE: Foundations, Metrics, and Tackling Technical Debt

This article introduces the fundamentals of Site Reliability Engineering (SRE), explains how to measure service stability with metrics like MTTR, MTBF, and availability, outlines the SRE workflow from prevention to post‑mortem, and discusses how to identify and reduce technical debt to improve system health.

OperationsSREreliability
0 likes · 18 min read
Understanding SRE: Foundations, Metrics, and Tackling Technical Debt
Java Captain
Java Captain
Oct 4, 2021 · Backend Development

The Hidden Pitfalls of Using Project Lombok in Java Development

This article reflects on a year of using Project Lombok, showing how its annotations can dramatically shrink Java boilerplate but also introduce version incompatibilities, forced dependencies, reduced readability, tighter coupling, and technical debt that may outweigh its short‑term convenience.

Lombokbest practicescode generation
0 likes · 10 min read
The Hidden Pitfalls of Using Project Lombok in Java Development
Java Backend Technology
Java Backend Technology
Aug 24, 2021 · Backend Development

Is Lombok a Blessing or a Curse? Uncovering Hidden Pitfalls in Java Development

This article examines the advantages and hidden risks of using Lombok in Java projects, illustrating how its annotations can dramatically reduce boilerplate code while also introducing version compatibility issues, forced dependencies, reduced readability, increased coupling, and technical debt, and suggests alternative approaches for cleaner code.

LombokSpring Bootbackend development
0 likes · 11 min read
Is Lombok a Blessing or a Curse? Uncovering Hidden Pitfalls in Java Development
macrozheng
macrozheng
Aug 17, 2021 · Backend Development

Why Lombok’s Magic Can Turn Your Java Code into a Debt Trap

The article reviews a year of using Project Lombok, showing how its annotations dramatically shrink Java boilerplate but also introduce version incompatibilities, forced dependencies, reduced readability, tighter coupling, and technical debt, urging careful consideration before adoption.

Lombokjavatechnical debt
0 likes · 11 min read
Why Lombok’s Magic Can Turn Your Java Code into a Debt Trap
Qunar Tech Salon
Qunar Tech Salon
Aug 5, 2021 · Fundamentals

Four Types of Code Hygiene: Understanding Programmers' Clean‑Code Habits

The article describes four distinct code‑hygiene personalities—Minimalist, Distance‑Creates‑Beauty, Precise‑Constraint, and Creative‑Craft—explaining how each habit improves code readability, reduces technical debt, and ultimately boosts team efficiency in software projects.

clean codecode hygieneprogramming habits
0 likes · 2 min read
Four Types of Code Hygiene: Understanding Programmers' Clean‑Code Habits
Programmer DD
Programmer DD
Jul 26, 2021 · Backend Development

Is Lombok a Hidden Threat? Uncovering the Risks Behind Java’s Code‑Gen Magic

This article examines Lombok’s ability to shrink Java boilerplate, walks through code transformations from verbose getters and setters to concise annotations, and critically evaluates five major drawbacks—including JDK compatibility, forced adoption, readability loss, tighter coupling, and technical debt—offering guidance on when to avoid it.

backend developmentcode generationjava
0 likes · 11 min read
Is Lombok a Hidden Threat? Uncovering the Risks Behind Java’s Code‑Gen Magic
Amap Tech
Amap Tech
Jul 16, 2021 · Fundamentals

Code Refactoring: Concepts, Practices, and Techniques

The article shares practical lessons from refactoring a ride‑hailing order system, explaining Martin Fowler’s definition of refactoring, distinguishing small (renaming, deduplication) and large (architectural redesign) efforts, outlining typical code smells, and detailing a structured pre‑, during‑, and post‑refactoring process to improve maintainability, reduce bugs, and accelerate development.

Code RefactoringSoftware Engineeringbest practices
0 likes · 19 min read
Code Refactoring: Concepts, Practices, and Techniques
IT Architects Alliance
IT Architects Alliance
Jul 4, 2021 · Industry Insights

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

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

Build OptimizationPlatform designcode decay
0 likes · 25 min read
Why Do Software Architectures Decay Over Time and How to Prevent It?
HomeTech
HomeTech
Jun 16, 2021 · R&D Management

Technical Debt Governance in Autohome's Cloud Platform: Theory and Practice

This article presents Autohome's Cloud Platform (Home Cloud) technical debt governance framework, defining ideal technical states, outlining five systematic steps—from factor collection to project execution—and sharing practical outcomes that have enhanced the competitiveness of its applications and development teams.

OperationsR&D ManagementSoftware Engineering
0 likes · 7 min read
Technical Debt Governance in Autohome's Cloud Platform: Theory and Practice
KooFE Frontend Team
KooFE Frontend Team
Jun 14, 2021 · Fundamentals

How to Write Clean, Readable JavaScript Code: Essential Practices

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

Team Collaborationclean codecode readability
0 likes · 11 min read
How to Write Clean, Readable JavaScript Code: Essential Practices
Java Interview Crash Guide
Java Interview Crash Guide
Jan 18, 2021 · Fundamentals

Why Code Reviews Matter: Boost Quality, Reduce Debt, and Empower Teams

This guide explains why code reviews are essential for maintaining product quality, preventing technical debt, fostering team knowledge sharing, and improving developer skills, while also addressing common challenges, best‑practice processes, and practical examples to help teams implement effective reviews.

Code ReviewTeam Collaborationcode quality
0 likes · 20 min read
Why Code Reviews Matter: Boost Quality, Reduce Debt, and Empower Teams
Top Architect
Top Architect
Jan 4, 2021 · Fundamentals

Understanding Technical Debt: Causes, Impact, and Management

The article explains technical debt as the trade‑off of short‑term development convenience for long‑term cost, illustrates its effects through a content‑management system example, discusses design choices, responsibility, and Martin Fowler’s debt quadrants, and offers guidance on mitigating its impact.

Martin Fowlerproduct managementtechnical debt
0 likes · 9 min read
Understanding Technical Debt: Causes, Impact, and Management
21CTO
21CTO
Nov 26, 2020 · Fundamentals

Why Refactoring Matters: A Practical Guide to Cleaner Code

This article explains why refactoring is essential for maintaining legacy systems, defines refactoring as a controlled code‑restructuring technique that preserves observable behavior, and provides a step‑by‑step process—including when to start, when to stop, prerequisites, and practical tactics—to improve code quality and reduce technical debt.

Software Engineeringbest practicesclean code
0 likes · 13 min read
Why Refactoring Matters: A Practical Guide to Cleaner Code
IT Architects Alliance
IT Architects Alliance
Nov 4, 2020 · Industry Insights

When Should You Switch to Microservices? A Practical Evaluation Guide

This article examines the trade‑offs between monolithic and microservice architectures, outlines the benefits, costs, and technical prerequisites of microservices, and provides concrete criteria—such as business complexity, team size, and talent readiness—to help engineers decide the right moment to adopt a microservice approach.

Microservicesarchitecture evaluationdeployment
0 likes · 17 min read
When Should You Switch to Microservices? A Practical Evaluation Guide
IT Architects Alliance
IT Architects Alliance
Oct 8, 2020 · Fundamentals

Understanding Software Architecture: Core Concepts, Layers, and Evolution

This comprehensive guide explains what software architecture is, distinguishes systems, subsystems, modules, components, and frameworks, outlines architecture layers and classifications, describes strategic versus tactical design, tracks the evolution from monoliths to micro‑services, and highlights how to evaluate and avoid common architectural pitfalls.

MicroservicesSystem Designarchitecture patterns
0 likes · 25 min read
Understanding Software Architecture: Core Concepts, Layers, and Evolution
DevOps Cloud Academy
DevOps Cloud Academy
Sep 11, 2020 · Operations

Overcoming Common Obstacles in a DevOps Transformation: Lessons from VMware Mobile Products

This article outlines the typical challenges faced during a DevOps transformation—such as resistance to change, rushed feature delivery, technical debt, team structure, skill gaps, automation, environment provisioning, and cross‑team collaboration—and explains the practical solutions VMware applied to achieve faster, higher‑quality releases.

AutomationDevOpsTransformation
0 likes · 12 min read
Overcoming Common Obstacles in a DevOps Transformation: Lessons from VMware Mobile Products
DevOps Cloud Academy
DevOps Cloud Academy
Aug 20, 2020 · Operations

How DevOps Can Reduce Technical Debt During Cloud Migration

This article explains what technical debt is, why it accumulates in both development and operations, and outlines four DevOps‑driven strategies—including building cross‑functional teams, automation, containerization, and API‑centric design—to identify, track, and repay technical debt while improving cloud migration outcomes.

AutomationCI/CDDevOps
0 likes · 10 min read
How DevOps Can Reduce Technical Debt During Cloud Migration
DevOps
DevOps
Aug 19, 2020 · Operations

DevOps Lessons from the Knight Capital Group Collapse: A Case Study

The article analyzes the 2012 Knight Capital Group disaster, showing how a manual deployment error, lingering legacy code, missing kill‑switch, and inadequate monitoring caused a $4.6 billion loss within 45 minutes, and extracts key DevOps best‑practice lessons to prevent similar failures.

DevOpsdeploymentincident response
0 likes · 13 min read
DevOps Lessons from the Knight Capital Group Collapse: A Case Study
DevOps
DevOps
Jul 7, 2020 · Fundamentals

Built‑in Quality: Principles and Practices for Agile Software Development

Built‑in quality emphasizes integrating quality throughout the software development lifecycle, using agile principles, continuous integration, test‑driven development, code review, and shared code ownership to reduce technical debt, avoid rework, and ensure reliable, maintainable products.

Code ReviewQualityTest‑Driven Development
0 likes · 22 min read
Built‑in Quality: Principles and Practices for Agile Software Development
FunTester
FunTester
Jul 4, 2020 · R&D Management

Top Challenges Agile Testing Teams Face and How to Overcome Them

This article examines the most common obstacles agile testing teams encounter—from constantly changing requirements and neglecting cross‑browser testing to lack of automation, over‑emphasis on speed, unclear definitions of done, poor estimation, skill gaps, and technical debt—offering practical insights to address each issue.

Agile TestingAutomationcross‑browser
0 likes · 9 min read
Top Challenges Agile Testing Teams Face and How to Overcome Them
Java Backend Technology
Java Backend Technology
Jun 22, 2020 · Backend Development

Is Lombok Worth It? Uncovering the Hidden Costs of Java’s Magic Annotations

This article examines Project Lombok’s ability to cut boilerplate in Java, walks through before‑and‑after code examples, and reveals five major drawbacks—including JDK compatibility, forced adoption, readability issues, increased coupling, and technical debt—helping developers decide whether to embrace or avoid Lombok.

Lombokbackend developmentcode generation
0 likes · 11 min read
Is Lombok Worth It? Uncovering the Hidden Costs of Java’s Magic Annotations
Java Backend Technology
Java Backend Technology
Jun 13, 2020 · Backend Development

Why Lombok Can Turn Your Java Code into a Hidden Liability

This article examines the trade‑offs of using Project Lombok in Java projects, showing how its syntactic sugar reduces boilerplate but can introduce technical debt, version‑compatibility issues, hidden coupling, and readability problems that may outweigh its short‑term benefits.

Lombokbackend developmentcode generation
0 likes · 12 min read
Why Lombok Can Turn Your Java Code into a Hidden Liability
Programmer DD
Programmer DD
Jun 12, 2020 · Backend Development

Is Project Lombok Worth It? A Year‑Long Developer’s Deep Dive

After a year of using Project Lombok, the author reflects on how the library initially simplifies Java boilerplate but eventually introduces technical debt, version‑compatibility issues, hidden complexity, and tighter coupling, urging teams to weigh its short‑term convenience against long‑term maintainability.

Lombokbackend developmentcode generation
0 likes · 10 min read
Is Project Lombok Worth It? A Year‑Long Developer’s Deep Dive
DevOps
DevOps
Apr 15, 2020 · Product Management

What Flows Through a Software Value Stream – Defining the Four Types of Flow Work Items

The article explains that to improve software delivery you must first agree on what actually flows through the value stream, evaluates existing metrics, introduces four mutually exclusive flow work‑item categories—including features, security/compliance, and technical debt—and shows how this lean, business‑centric view helps identify bottlenecks and drive productivity.

DevOpsflow metricssoftware value stream
0 likes · 11 min read
What Flows Through a Software Value Stream – Defining the Four Types of Flow Work Items
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
Mar 16, 2020 · R&D Management

Why Software Architects Should Write Code: Benefits, Risks, and Best Practices

The article argues that the common belief that architects need not code is a misconception, explaining how hands‑on coding improves architectural decisions, team collaboration, design quality, and product ownership while also addressing potential drawbacks and offering practical solutions.

CodingTeam Collaborationarchitect role
0 likes · 11 min read
Why Software Architects Should Write Code: Benefits, Risks, and Best Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 19, 2020 · Fundamentals

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

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

Project ManagementSoftware Engineeringcode quality
0 likes · 9 min read
How to Identify, Break, and Prevent Technical Debt in Software Projects
Youzan Coder
Youzan Coder
Jan 3, 2020 · Operations

Improving Software Development Efficiency through Lean Practices and DevOps at Youzan

Youzan’s Efficiency Improvement team applied lean manufacturing principles and DevOps practices—quantifying technical debt, automating high‑coverage unit tests, streamlining continuous integration, and fostering a culture with visual CI indicators—to eliminate waste, accelerate integration cycles, and markedly boost overall software development efficiency.

DevOpsLeanSoftware Efficiency
0 likes · 12 min read
Improving Software Development Efficiency through Lean Practices and DevOps at Youzan
Programmer DD
Programmer DD
Jul 19, 2019 · Fundamentals

Why High‑Quality Code Actually Reduces Costs, Not Increases Them

The article argues that investing in internal software quality—clean architecture, low technical debt, and well‑structured code—lowers long‑term development costs and speeds up feature delivery, contradicting the common belief that higher quality always means higher expense.

Cost Efficiencyinternal qualitysoftware architecture
0 likes · 17 min read
Why High‑Quality Code Actually Reduces Costs, Not Increases Them
21CTO
21CTO
Apr 3, 2019 · Operations

Why Software Quality Fails: Black Swans, Butterfly Effects, and Technical Debt

The article explores how unpredictable black‑swan events, the butterfly effect, Murphy's law, rapid business growth, technical debt, tool choices, complex domains, documentation, and leadership all combine to threaten software stability, and proposes agile, systematic, and quality‑centric approaches to mitigate these risks.

Software Engineeringagileblack swan
0 likes · 22 min read
Why Software Quality Fails: Black Swans, Butterfly Effects, and Technical Debt
Programmer DD
Programmer DD
Feb 25, 2019 · R&D Management

Why Chinese Tech Teams Overtime While US Teams Don’t: A Deep Dive

The article examines why Chinese software engineers face severe overtime compared to their U.S. counterparts, analyzing product decision processes, the low technical voice in China, infrastructure shortcomings, and cultural attitudes toward work‑life balance, revealing systemic factors behind the disparity.

InfrastructureR&D Managementovertime
0 likes · 9 min read
Why Chinese Tech Teams Overtime While US Teams Don’t: A Deep Dive
21CTO
21CTO
Jan 19, 2019 · R&D Management

What Huawei’s 20‑Year IPD Journey Reveals About Building Trustworthy Software

The article examines Huawei’s two‑decade evolution of Integrated Product Development (IPD), highlighting how disciplined software engineering practices, architecture, security, and cultural change are essential for delivering trustworthy, high‑quality products amid geopolitical pressures.

IPDSoftware Engineeringarchitecture
0 likes · 16 min read
What Huawei’s 20‑Year IPD Journey Reveals About Building Trustworthy Software
DevOps
DevOps
Jan 6, 2019 · Fundamentals

Insights from Huawei’s Letter on Elevating Software Engineering Capability and Building Trustworthy High‑Quality Products

The article reflects on Huawei’s public letter urging a comprehensive upgrade of software‑engineering practices, explaining concepts such as IPD, the project‑management triple constraint, architecture, technical debt, security, and cultural change, while emphasizing the need for trustworthy, high‑quality software development.

Qualityarchitectureprocess improvement
0 likes · 18 min read
Insights from Huawei’s Letter on Elevating Software Engineering Capability and Building Trustworthy High‑Quality Products
21CTO
21CTO
Oct 5, 2018 · R&D Management

What Should a CTO Really Do? Insights on Leadership, Culture, and Process

The article explores the multifaceted role of a CTO, covering responsibilities from hands‑on technical work to strategic leadership, team organization, cultural stewardship, process optimization, technical debt management, and security, while also highlighting Yibao Payment's technical practices and industry positioning.

CTOleadershiporganizational culture
0 likes · 13 min read
What Should a CTO Really Do? Insights on Leadership, Culture, and Process
Java Backend Technology
Java Backend Technology
Aug 16, 2018 · Fundamentals

Why Big Tech Sticks to Outdated Tech: Code Chaos and Process Pitfalls

The article examines why many large, well‑known tech companies suffer from messy code, chaotic development processes, and reliance on outdated technologies, exploring the underlying personnel dynamics, reconstruction costs, and the tension between business and technical value.

career advicecode qualitylarge companies
0 likes · 11 min read
Why Big Tech Sticks to Outdated Tech: Code Chaos and Process Pitfalls
DevOpsClub
DevOpsClub
May 25, 2018 · Backend Development

What Entropy Theory Reveals About Software Architecture Evolution and Technical Debt

This article applies the thermodynamic concept of entropy to software systems, explaining how entropy increase manifests as technical debt and how deliberate entropy reduction through architectural evolution, micro‑services, DevOps practices, and organizational changes can sustain system vitality and productivity.

Microservicesentropytechnical debt
0 likes · 18 min read
What Entropy Theory Reveals About Software Architecture Evolution and Technical Debt
DevOps
DevOps
May 23, 2018 · Operations

Applying the Second Law of Thermodynamics to Software Architecture, Technical Debt, and Evolution

The article explores how the concept of entropy from the second law of thermodynamics maps onto software systems and organizations, describing entropy increase and reduction, negative entropy, four governing rules, technical debt, progressive architecture patterns such as the strangler and refactoring approaches, and real‑world examples like Amazon’s evolution to microservices.

DevOpsMicroservicesentropy
0 likes · 17 min read
Applying the Second Law of Thermodynamics to Software Architecture, Technical Debt, and Evolution
21CTO
21CTO
Nov 5, 2017 · R&D Management

When a Genius Turns Toxic: What We Learned by Firing Our Star Developer

The article recounts how a brilliant but isolated developer named Rick became a bottleneck, leading the team to miss deadlines, and how firing him forced a shift to collaborative development that dramatically improved productivity and reduced technical debt.

Product DeliveryR&Dsoftware development
0 likes · 9 min read
When a Genius Turns Toxic: What We Learned by Firing Our Star Developer
21CTO
21CTO
Jul 26, 2017 · Fundamentals

Why Writing One Million Lines of Code Is a Myth—and How to Write Quality Code

This article debunks the myth of writing a million lines of code, explains why code quantity matters less than quality, and offers ten practical steps—including solid fundamentals, coding standards, design principles, refactoring, technical debt management, code reviews, static analysis, unit testing, self‑testing, and leveraging open source—to help developers produce high‑quality software efficiently.

Code ReviewSoftware EngineeringStatic Analysis
0 likes · 10 min read
Why Writing One Million Lines of Code Is a Myth—and How to Write Quality Code
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 Designclean codecode quality
0 likes · 13 min read
Why Refactoring Matters: A Practical Guide to Cleaner Code
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.

Software Engineeringarchitecturerefactoring
0 likes · 13 min read
12 Essential Rules for Successful Architecture Refactoring (Full Guide)
DevOps
DevOps
Mar 29, 2017 · Fundamentals

Starting an Agile Development Team: Practices, Challenges, and Tips

This article outlines how teams can transition to agile development by adopting Scrum or Kanban, emphasizing self‑organization, realistic planning, continuous integration, automated testing, regular retrospectives, and servant‑leadership to sustainably deliver business value while managing technical debt.

Software testingcontinuous integrationscrum
0 likes · 10 min read
Starting an Agile Development Team: Practices, Challenges, and Tips
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
转转QA
转转QA
Sep 11, 2016 · Mobile Development

Challenges and Improvement Practices for Mobile App Development Teams

As smartphones become full‑featured computers, traditional PC/M functionalities are migrating to mobile apps, causing teams to face pre‑, mid‑, and post‑development challenges such as coordination friction, technical debt, and high coupling, and the article proposes concrete improvement measures including clearer collaboration, reduced coupling, parallel versioning, and iterative release cycles.

DecouplingRelease Managementmobile development
0 likes · 10 min read
Challenges and Improvement Practices for Mobile App Development Teams
Qunar Tech Salon
Qunar Tech Salon
Jun 22, 2016 · Fundamentals

Three Life Lessons Learned from 17 Years of Programming

After seventeen years of coding, the author shares three enduring lessons—balancing trade‑offs, valuing clarity over mere brevity, and treating technical debt as a manageable asset—illustrated with real‑world examples, ORM discussions, and code snippets that apply both to software development and everyday decisions.

Software Engineeringcode claritydecision making
0 likes · 8 min read
Three Life Lessons Learned from 17 Years of Programming
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.

Software Engineeringrefactoringrisk management
0 likes · 12 min read
Why Technical Debt Accumulates and How to Tackle It Effectively
21CTO
21CTO
May 15, 2016 · Fundamentals

The Programmer’s Paradox: Why Top Developers Spend Most Time on Disliked Tasks

The article explains the paradox that good programmers spend the majority of their time on tasks, technologies, and tools they dislike because these “bad” technologies consume disproportionate effort, while automation‑friendly work is quickly delegated, leading to chronic frustration despite their expertise.

AutomationSoftware Engineeringdeveloper productivity
0 likes · 6 min read
The Programmer’s Paradox: Why Top Developers Spend Most Time on Disliked Tasks
dbaplus Community
dbaplus Community
Apr 11, 2016 · Operations

Can External Quality Acceptance Drive DevOps Monitoring and Eliminate Technical Debt?

This article explains how focusing on non‑functional quality during external acceptance testing can drive DevOps teams to improve system monitorability, reduce technical debt, and establish concrete change‑control, acceptance, and performance verification processes for both operational and business‑level observability.

DevOpschange managementobservability
0 likes · 15 min read
Can External Quality Acceptance Drive DevOps Monitoring and Eliminate Technical Debt?
Qunar Tech Salon
Qunar Tech Salon
Feb 26, 2016 · Fundamentals

15 Workplace Barriers to Better Code

The article lists fifteen common workplace obstacles—such as endless meetings, email overload, misguided productivity metrics, technical debt, non‑technical managers, poor documentation, distracting environments, and a relentless chase for the newest tools—that hinder developers from writing high‑quality code efficiently.

coding barriersproductivityprogrammer challenges
0 likes · 13 min read
15 Workplace Barriers to Better Code
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