BestHub
Sign in
Tagged articles
175 articles
Page 2 of 2
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 EngineeringTechnical Debt
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.

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

Software ArchitectureTechnical Debtcode quality
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 ExtensionsJetBrainsTechnical Debt
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.

Developer ExperienceFrontend ArchitectureTechnical Debt
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 EngineeringTechnical Debt
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 reductionSoftware qualityTechnical Debt
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 EngineeringTechnical Debtprioritization
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.

SRETechnical Debtmonitoring
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.

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

Code GenerationJavaLombok
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.

Backend DevelopmentCode GenerationJava
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.

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

Technical Debtclean codecode hygiene
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 ArchitectureSoftware Engineering
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 OptimizationSoftware ArchitectureTechnical Debt
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.

Technical Debtclean 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 reviewSoftware qualityTechnical Debt
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 FowlerTechnical Debtproduct-management
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 EngineeringTechnical Debtbest practices
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.

DeploymentMicroservicesTechnical Debt
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.

Architecture PatternsMicroservicesScalability
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.

AutomationCross-Team CollaborationDevOps
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.

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

DeploymentDevOpsTechnical Debt
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 reviewTechnical Debtagile
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 TestingAutomationTechnical Debt
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.

Backend DevelopmentCode GenerationJava
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.

Backend DevelopmentCode GenerationJava
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.

Backend DevelopmentCode GenerationJava
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.

DevOpsTechnical Debtflow metrics
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 OptimizationSoftware ArchitectureTechnical Debt
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.

Software ArchitectureTechnical Debtarchitect 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 EngineeringTechnical Debt
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.

Software ArchitectureSoftware qualityTechnical Debt
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 EngineeringSoftware qualityTechnical Debt
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.

InfrastructureOvertimeR&D management
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 EngineeringTechnical Debt
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.

SecurityTechnical Debtarchitecture
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.

CTOLeadershipTechnical Debt
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.

Technical Debtcareer advicecode quality
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.

MicroservicesTechnical Debtentropy
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.

DevOpsMicroservicesTechnical Debt
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&DTechnical Debt
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 EngineeringTechnical Debt
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.

Technical Debtclean 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 EngineeringTechnical Debtarchitecture
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 TestingTechnical Debtcontinuous integration
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 OptimizationSoftware ArchitectureTechnical Debt
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.

DecouplingMobile DevelopmentTechnical Debt
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 EngineeringTechnical Debtcode clarity
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 EngineeringTechnical Debtrefactoring
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 EngineeringTechnical Debt
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.

DevOpsObservabilityTechnical Debt
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.

Technical Debtcoding barriersproductivity
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.

Engineering managementTechnical Debtbest practices
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 OptimizationTechnical Debtproject scaling
0 likes · 24 min read
Why Software Architectures Decay Over Time and How to Fight It
21CTO
21CTO
Jan 2, 2016 · Operations

How a Single Deployment Mistake Cost Knight Capital $460 Million

A disastrous software deployment at Knight Capital left an outdated code path active on one server, causing millions of erroneous orders that wiped out $460 million in seconds and highlighted critical failures in testing, monitoring, and incident response processes.

Technical DebtTrading Systemsdeployment failure
0 likes · 7 min read
How a Single Deployment Mistake Cost Knight Capital $460 Million
Qunar Tech Salon
Qunar Tech Salon
Dec 29, 2015 · Artificial Intelligence

Technical Debt in Machine Learning Systems

The paper examines how machine‑learning systems inherit unique forms of technical debt—such as boundary erosion, entanglement, hidden feedback loops, and data‑dependency issues—and discusses mitigation strategies, measurement techniques, and cultural changes needed to maintain sustainable, reliable ML deployments.

Software EngineeringTechnical Debtdata dependencies
0 likes · 26 min read
Technical Debt in Machine Learning Systems
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Oct 16, 2015 · Artificial Intelligence

Building Machine Learning Systems in Small Teams: Practices, Pitfalls, and Lessons from Dangdang

This talk shares the experience of a small machine‑learning team at Dangdang, describing how they built a recommendation system from scratch, the tools and processes they used, the challenges of limited personnel, and the many pitfalls they encountered while iterating toward a production‑ready solution.

ML pipelineTechnical Debtbest practices
0 likes · 21 min read
Building Machine Learning Systems in Small Teams: Practices, Pitfalls, and Lessons from Dangdang
21CTO
21CTO
Sep 7, 2015 · Fundamentals

When Is Rewriting Code Worth It? Lessons on Cost, Risk, and Value

The article argues that rewriting already‑deployed code rarely adds real product value, incurs high costs and risks, and should only be considered when the existing system is so outdated that a fresh start is the only viable solution.

Product DevelopmentSoftware EngineeringTechnical Debt
0 likes · 6 min read
When Is Rewriting Code Worth It? Lessons on Cost, Risk, and Value
MaGe Linux Operations
MaGe Linux Operations
Aug 21, 2015 · Fundamentals

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

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

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

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

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

Software ArchitectureTechnical Debtcodebase decay
0 likes · 24 min read
Why Do Software Architectures Decay Over Time and How to Stop It?
Architect
Architect
May 12, 2015 · Fundamentals

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

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

Data-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
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
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
Qunar Tech Salon
Mar 26, 2015 · R&D Management

Why Software Architecture Decays Over Time and How to Mitigate It

The article analyzes how long‑running software projects inevitably suffer architectural decay due to growing codebases, team size, and build complexity, and proposes practical strategies such as modularization, phased and distributed builds, component isolation, and disciplined technology adoption to keep systems sustainable.

Build OptimizationMicroservicesSoftware Architecture
0 likes · 23 min read
Why Software Architecture Decays Over Time and How to Mitigate It