Tagged articles
software complexity
27 articles · Page 1 of 1
The article surveys classic definitions of software complexity from Ousterhout, Simon, Mitchell, Gall, Taleb, Tesler, Gurley, and Wolfram, then proposes three dimensions—structure, behavior, and evolution—for analyzing complex software systems.
Herbert SimonJohn OusterhoutMelanie Mitchell
0 likes · 8 min read

The article explores how software engineering research is shifting from human-centered to agent-centered development (Harness Engineering), identifying key research questions around software complexity characterization, machine-readable knowledge representation, agent team collaboration, and adapting traditional SE theories, while advising against investing in generic agent frameworks already dominated by large companies.
AI agentsHarness Engineeringagent collaboration
0 likes · 5 min read

This technical briefing curates 14 deep-dive articles covering AI agent evaluation methodologies, real-world task benchmarking, Google engineering lessons, Rust vs C assembly performance, MCP tool calling internals, structured logging design, minimalist agent architectures, Codex agent internals, historical developer replacement attempts, observability evolution, vLLM memory leak debugging, hotspot optimization pitfalls, and LLM non-determinism root causes.
AI agentsEvaluationLLM internals
0 likes · 9 min read

The article argues that complexity in software cannot be eliminated, only shifted to well‑defined places, explains why abstractions leak, explores the limits of local consequence, and shows how eliminating duplication and thoughtful layering can still reduce overall complexity.
abstractioncode organizationlocal consequence
0 likes · 9 min read

The article examines how AI can speed up code generation yet fails to reduce the fundamental complexities of software development, shifting challenges to new areas such as prompt engineering, consistency, changeability, and invisibility, and argues that future developers must master AI to manage, not replace, complexity.
AI programmingcode generationdeveloper skills
0 likes · 9 min read

While AI can generate code at unprecedented speed, this article argues that it does not eliminate software development complexity but merely shifts it to new layers such as prompt engineering, governance, and architectural consistency, leaving the core challenges intact.
AI programmingBrooks' Mythical Man-Monthaccidental complexity
0 likes · 9 min read

The article examines the rapid growth and increasing complexity of edge AI NPUs, discussing challenges in software and hardware acceleration, supply‑chain constraints, and the need for integrated engine solutions to sustain performance and power efficiency.
NPUedge AIsoftware complexity
0 likes · 9 min read

This article explains what software complexity means, how it is measured and classified, outlines the negative impacts of high business complexity, and presents concrete architectural, coding, and configuration techniques to reduce complexity and improve maintainability.
code refactoringconfigurationdomain-driven design
0 likes · 13 min read

The article explains the concept and measurement of software complexity, its impact on development cost and stability, common causes in business systems, and presents a set of architectural, coding, and configuration practices—including domain splitting, layered design, clear commenting, and configurable rules—to effectively reduce and manage complexity.
Best Practicescode refactoringconfiguration
0 likes · 12 min read

This article examines the root causes of software complexity, explains how to quantify it using metrics such as Halstead, cyclomatic and Ousterhout complexity, showcases real code examples, and offers practical strategies—including high cohesion, low coupling, strategic design, documentation, and refactoring—to prevent and reduce complexity in large systems.
Halsteadcode metricscyclomatic complexity
0 likes · 22 min read

This article explains what Domain‑Driven Design (DDD) is, why it targets business‑logic complexity, examines its suitability for front‑end development, and offers practical strategies to reduce front‑end technical and business complexity by applying DDD principles.
domain-driven designsoftware complexity
0 likes · 21 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 essay argues that complexity is an unavoidable, persistent element of software development that cannot be eliminated but must be managed, illustrating this through reflections on build tools, design trade‑offs, resilience engineering, and the need to acknowledge and strategically place complexity within systems.
Design Principlesresilience engineeringsoftware complexity
0 likes · 10 min read

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

This article explores how software projects often become tangled by accidental complexity, contrasting it with the unavoidable essential complexity, and shows how principles like KISS, Occam's Razor, and thoughtful design can help keep systems simple and maintainable.
KISS principleaccidental complexityessential complexity
0 likes · 13 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 breaks down the massive complexity of Windows by citing code‑line counts for XP, Vista and 7, detailing the roughly thousand‑person development effort across 23 specialized teams, and illustrating the sheer size of the OS with folder‑size screenshots and paper‑length calculations.
OS Architecturecode-linesdevelopment teams
0 likes · 6 min read

The article explains Yanxuan’s “boundary governance” approach—using horizontal layering and vertical domain decomposition to isolate complexity—by analyzing and redefining business, system, and organizational boundaries, planning twelve core business blocks, continuously reviewing them, and applying project‑based, consensus‑driven, and forward‑looking strategies to resolve boundary issues and strengthen the middle‑platform architecture.
boundary governancebusiness platformdevelopment management
0 likes · 13 min read


21CTOApr 26, 2022 · Fundamentals
This article explores the nature of software complexity, its rational and sensory definitions, common symptoms such as change amplification, cognitive load and unknown unknowns, and contrasts tactical programming practices with strategic design approaches to help engineers manage and reduce complexity over time.
architectural patternscode qualitysoftware complexity
0 likes · 21 min read


ITPUBMar 21, 2022 · Fundamentals
This article explores why software systems inevitably become more entropic and complex, draws parallels with physical entropy and the Constructal Law, identifies sources of uncertainty, scale, and cognitive cost, and presents practical approaches such as isolating core kernels, adopting Domain‑Driven Design, and applying Clean Code principles to keep systems maintainable.
Clean Codeanemic modelcognitive cost
0 likes · 18 min read


DevOpsMar 4, 2022 · Cloud Native
The article examines how the rapid rise of micro‑services, containers, and cloud‑native platforms has dramatically increased software complexity, threatening developer productivity, and discusses industry perspectives and practical approaches—such as internal developer platforms and curated toolsets—to regain control and deliver value.
Cloud NativeInternal Developer Platformmicroservices
0 likes · 14 min read


21CTOMar 3, 2022 · Fundamentals
The article explores the nature of software complexity, contrasting rational metrics like McCabe cyclomatic complexity with the subjective view of John Ousterhout, identifies symptoms such as change amplification, cognitive load and unknown unknowns, and proposes strategic design over tactical programming to control architectural decay.
architectural governancesoftware complexitysoftware design
0 likes · 21 min read


21CTODec 1, 2021 · Cloud Native
Modern software’s soaring complexity—from monolithic apps to micro‑service, container‑based, cloud‑native ecosystems—is overwhelming developers, forcing them to juggle endless tools, security, and performance demands, while organizations adopt internal platforms and curated “golden paths” to regain control and deliver value efficiently.
DevOpscloud-nativeinternal platforms
0 likes · 13 min read

This article explores the evolution of the Vision low‑code platform, introduces the Gems visual‑building engine, and explains how a modular architecture of renderer, editor, and material libraries addresses both business and technical challenges while controlling software complexity.
Frontend Architectureengine designlow-code
0 likes · 17 min read

The article explains why large distributed applications quickly become complex, identifies cognitive‑load and collaboration‑cost as the two key dimensions of software complexity, analyses concrete causes such as poor logic, mismatched models, bad API design, naming and testing gaps, and offers practical principles for keeping complexity under control.
code designcognitive loadcollaboration cost
0 likes · 26 min read

This article explores why massive distributed applications quickly become complex, identifies cognitive load and collaboration cost as the two main dimensions of software complexity, and offers practical design, naming, testing, and documentation strategies to keep systems maintainable over time.
Design Principlescode qualitycognitive load
0 likes · 25 min read

By using abstraction to model common concepts and composition to build complex behavior from simple, pure‑function building blocks like map, filter, and reduce, the article shows how functional programming techniques underpin Redux and React, providing a systematic way to tame front‑end software complexity.
CompositionReactRedux
0 likes · 22 min read
