Tagged articles
complexity management
32 articles · Page 1 of 1

ITPUBOct 23, 2026 · R&D Management
This article argues that the most important capability for a technical lead is not coding or architecture skill, but the ability to make correct decisions amid complex business, system, and organizational dynamics — defining direction, boundaries, and collaboration rules to manage complexity.
career transitioncomplexity managementdecision making
0 likes · 7 min read


ITPUBSep 23, 2026 · R&D Management
In this interview, CTO Weng Yifei shares insights on making architecture decisions under resource constraints, contrasting big-tech and startup environments, managing technical debt, integrating AI responsibly, and building governance mechanisms for sustainable technology adoption. He emphasizes controlling complexity, establishing lightweight AI governance, evaluating true ROI beyond local efficiency, and designing auditability for probabilistic systems.
AI governanceROI evaluationarchitecture decision-making
0 likes · 27 min read

This article explores abstraction as the fundamental technique for managing complexity in computer science, covering its philosophical roots, computational abstraction via functions and higher-order functions, data abstraction with abstraction barriers, and metalinguistic abstraction through language design.
abstractionabstraction barrierscomplexity management
0 likes · 11 min read


ITPUBJul 11, 2026 · R&D Management
The article explains that truly great technical leaders appear less busy because they focus on anticipating future failure points and controlling system complexity, rather than merely reacting to immediate issues, which leads to more stable systems, smoother teams, and faster project delivery.
complexity managementrisk mitigationsoftware architecture
0 likes · 7 min read

The article explains that software engineering’s recurring problems stem from three inherent contradictions—state‑space explosion versus human cognition, inevitable iteration versus entropy, and collective production versus information loss—and presents a four‑layer failure model and a concrete first‑principle framework to guide sustainable system design, even in the AI era.
AI toolscomplexity managementfirst principles
0 likes · 14 min read

The article analyzes how AI‑generated code and rapid development practices expose hidden technical debt and security risks, revisits historic software failures, and argues that solid software engineering fundamentals and a new "Software Engineering 3.0" paradigm are essential for safe, reliable software in the intelligent age.
AI code generationSoftware Engineering 3.0Spec-Driven Development
0 likes · 14 min read

The article explains why coding skill alone isn’t enough, outlines the four essential architectural mindsets, shows how neglecting business, people, technology, and operational complexity turns systems into spaghetti, and offers concrete career advice for engineers at every level.
architectural thinkingcareer developmentcomplexity management
0 likes · 10 min read

The article explores structural thinking as the core mindset of software engineers, breaking it into three levels—conception, insight, and understanding—while emphasizing runtime and evolutionary structures for managing complexity, enabling collaboration, and sustaining long-term system health.
Conway's Lawcomplexity managementevolutionary architecture
0 likes · 8 min read

This article explores the fundamental nature of software architecture by examining core models, the role of immutable and mutable elements, extension points, and how embracing simplicity can transform complex systems into elegant, adaptable solutions.
Design Principlescomplexity managementcore model
0 likes · 6 min read

This article explores the essence of software architecture, tracing its definition, its role in solving division‑of‑labor challenges, and how a pragmatic, balanced design that treats architecture as software design itself can deliver sustainable value while navigating business complexity, team coordination, and evolving requirements.
Design Principlescomplexity managementdomain-driven design
0 likes · 47 min read

This article explains how modeling, especially Model‑Driven Architecture (MDA), helps software architects identify and manage complexity by abstracting business, logical, and technical concerns into CIM, PIM, and PSM layers, and provides practical principles for prioritizing architectural decisions.
MDASoftware Modelingcomplexity management
0 likes · 8 min read


DevOpsSep 19, 2024 · Fundamentals
This article explains the fundamentals of software architecture, covering its definition, key components such as systems, modules, components, and subsystems, and explores vertical (layered) and horizontal (modular) architectures, design principles, complexity evaluation, cross‑platform considerations, and practical guidelines for building maintainable applications.
App DevelopmentDesign Principlescomplexity management
0 likes · 10 min read


DevOpsJul 18, 2024 · Fundamentals
The article explains architectural thinking as a systematic approach to decompose problems, highlighting five core principles—abstraction, global perspective, layered design, evolutionary mindset, and standardization—that help engineers manage complexity, improve design quality, and adapt software systems over time.
Design Principlesabstractioncomplexity management
0 likes · 10 min read

An in‑depth exploration shows how viewing software as a system, mastering architectural models like 4+1, C4 and TOGAF, and applying the Cynefin framework for complexity can guide developers from basic system concepts to effective microservice design and complexity management.
C4 modelCynefincomplexity management
0 likes · 20 min read

This article explores how a systematic, high‑dimensional view of software systems—covering system theory, architectural models like 4+1, C4 and TOGAF, micro‑service design, and the Cynefin complexity framework—helps developers move from code‑writing to strategic architecture while managing complexity.
C4 modelCynefin frameworkDesign Principles
0 likes · 21 min read

After fifteen years of software development, the author learns that writing good code demands rapid trial‑and‑error, modular design, SOLID principles, early unit testing, and controlled complexity, while avoiding perfectionism, embracing stakeholder communication, and focusing on high‑ROI learning to create reusable, maintainable tools.
Learningcareer developmentcode quality
0 likes · 21 min read


21CTOFeb 7, 2024 · Fundamentals
This article explains how architects manage complexity through abstraction, offering practical induction and deduction techniques to identify commonalities, relationships, and characteristics, and illustrating these methods with real‑world examples like installment financing and Java technology.
abstractioncomplexity managementdeductive reasoning
0 likes · 9 min read


DevOpsJan 2, 2024 · Fundamentals
This article explores the fundamentals of software architecture, discussing entropy, the dual value of behavior and structure, core design principles such as SOLID, DRY, layering, orthogonality, component coupling, boundary definition, communication patterns, and modeling tools, while also offering practical guidance for building maintainable systems.
DRYDesign PrinciplesSOLID
0 likes · 18 min read

This article details Qunar's end‑to‑end digital quality measurement system, describing how over 100 indicators were defined, filtered, and organized into a hierarchical model, how the platform ingests and visualizes data, and how continuous governance and PDCA cycles improve system stability and reduce complexity.
R&D metricscomplexity managementdigital measurement
0 likes · 21 min read

This article explains Domain-Driven Design as a methodological approach for handling software complexity by aligning business, system, and organizational structures through modeling, detailing its core concepts, goals, key methods, and real‑world case studies from large‑scale systems.
DDDcomplexity managementdomain-driven design
0 likes · 10 min read

Domain‑Driven Design is a methodological approach that refactors large, complex systems by aligning business language with architecture through metaphors, layering, refinement and abstraction, organizing code into high‑cohesion, low‑coupling bounded contexts, and applying strategic and tactical modeling—illustrated by Tencent Video case studies and contrasting lightweight versus rigorous practice styles.
Strategic ModelingTactical Modelingcomplexity management
0 likes · 10 min read

This article introduces the fundamentals of enterprise architecture, defining its scope, reference models, and maturity stages, and explains how architects manage complexity, control costs, ensure SLA compliance, and apply iterative, partitioning, and simplification techniques to modernize enterprise IT systems.
Cost OptimizationModernizationSLA
0 likes · 14 min read

This article explains why architecture design, especially Domain‑Driven Design, is essential for controlling the complexity, cost, and scalability of microservice systems, detailing common misconceptions, sources of complexity, and concrete steps to define clear domain and service boundaries.
Backendcomplexity managementdomain-driven design
0 likes · 26 min read

This article explains that an engineer's primary responsibility is to solve business problems, explores the challenges across a product's lifecycle, outlines software complexity dimensions, and demonstrates how Domain‑Driven Design, strategic and tactical patterns, and modern architectural styles like Hexagonal and CQRS can effectively manage that complexity.
complexity managementcqrshexagonal-architecture
0 likes · 31 min read

The article explains the definition of complexity, analyzes its causes and how they manifest in software systems through scale and structure, and proposes domain‑driven design techniques such as bounded contexts, layered architecture, and change‑boxing to manage and reduce software complexity.
Design Principlescomplexity managementsoftware complexity
0 likes · 8 min read

The article argues that complexity is an unavoidable aspect of software development that cannot be eliminated, only managed or transferred, and discusses how design choices, build‑tool trade‑offs, and knowledge models influence the way engineers cope with inevitable complexity.
Design Principlescomplexity managementresilience engineering
0 likes · 7 min read

This article explains how managing complexity by layering responsibilities and introducing an MVP architecture separates UI rendering from business logic in Android search features, illustrating the problems of high coupling and low cohesion with concrete Kotlin code examples and discussing AB testing and decorator patterns.
AndroidMVParchitecture
0 likes · 18 min read

This article explains how Domain‑Driven Design (DDD) helps teams manage rising business and technical complexity by promoting a ubiquitous language, strategic and tactical design, layered and hexagonal architectures, and seamless integration with microservices, enabling rapid adaptation and robust, maintainable systems.
complexity managementcqrsdomain-driven design
0 likes · 42 min read

This article shares practical experiences and insights on applying Domain‑Driven Design to the supply‑chain product domain, explaining software complexity, core DDD concepts, layered architecture, bounded contexts, and implementation challenges, and offering concrete techniques for continuous model evolution.
complexity managementdomain-driven designsupply chain
0 likes · 12 min read

This article examines common misconceptions about software architecture, explains that its core purpose is to manage system complexity, offers practical guidance for identifying complexity hotspots, and presents a concrete university student‑management system case study to illustrate effective architectural decision‑making.
Design PrinciplesR&Dcomplexity management
0 likes · 11 min read

This article explains why excessive if‑else code harms maintainability, introduces polymorphic extension and code‑separation strategies, and presents a matrix‑analysis methodology that uses multi‑dimensional thinking to systematically design, model, and simplify complex business workflows.
Business LogicPolymorphismcode organization
0 likes · 14 min read

This article explains how to replace tangled if‑else branches in complex business code by using multidimensional matrix analysis, polymorphic extensions, and code separation, providing practical examples, design guidelines, and a step‑by‑step methodology for clearer, more maintainable software architecture.
Business LogicPolymorphismcomplexity management
0 likes · 16 min read
