Tagged articles
Complexity
67 articles · Page 1 of 1
The article first explains why Tencent offers are highly valued, noting candidates often interview multiple times, then presents a skyline‑keeping coding interview question, detailing the optimal O(m × n) solution using row and column maxima and a Java implementation.
AlgorithmComplexityInterview
0 likes · 5 min read

The article compares RAG and ontology‑based knowledge graphs, showing that although both appear simple in demos, ontology often delivers higher precision with greater engineering cost, and argues that true simplification comes from architectural trade‑offs rather than choosing a supposedly "simple" technology.
AIComplexityEnterprise Knowledge Management
0 likes · 9 min read

The article explains that backend engineers often view frontend work as easy because it changes rapidly with user preferences, while backend deals with stable, long‑standing challenges like data consistency, making each side complex in fundamentally different ways.
BackendComplexityUser Experience
0 likes · 4 min read


TonyBaiMay 29, 2026 · Frontend Development
The article examines the escalating complexity of modern frontend development, citing antirez’s critique of SPA toolchains, outlining the exhaustive build steps required for a simple button, and evaluating HTMX as a minimalist alternative while presenting diverse developer perspectives on the trade‑offs.
ComplexityHTMXReact
0 likes · 12 min read

The article argues that microservices are often over‑hyped, add significant complexity and operational cost, and contribute little to a company's success, making them unsuitable for most small‑team or low‑traffic projects while suggesting a modest 80% monolith‑20% microservice split for rare high‑reuse cases.
Complexityarchitecturemicroservices
0 likes · 9 min read

In a Netflix talk, senior engineer Jake Nations reveals how AI can instantly produce code yet leave developers clueless, explains the historic software crisis, distinguishes essential from accidental complexity, and outlines a three‑stage "context compression" process to keep speed without sacrificing comprehension.
AIComplexityNetflix
0 likes · 20 min read

This article explores how architects can reconcile flexibility and complexity through layered design, progressive complexity management, adaptive architecture, and team‑capacity alignment, offering practical principles, decision‑making frameworks, and monitoring metrics to guide sustainable system evolution.
ComplexityDesignarchitecture
0 likes · 11 min read

The article argues that software engineering is fundamentally a discipline for managing complexity, entropy, and information flow, and that understanding its first‑principles—trade‑offs, abstraction, process, feedback, and automation—is essential to avoid ritualistic practices and deliver sustainable value.
ComplexityFeedbackabstraction
0 likes · 10 min read

This article explains how to determine whether an integer array contains any duplicate values by iterating through the elements, using an associative map in PHP to track occurrences, and returning true if a repeat is found or false otherwise, including code examples and analysis of time and space complexity.
ComplexityPHP
0 likes · 4 min read

This article explains the principles of queues and stacks, demonstrates how to simulate a FIFO queue using two LIFO stacks in PHP, provides full source code, usage examples, complexity analysis, and discusses practical applications and possible extensions.
AlgorithmComplexityPHP
0 likes · 5 min read

This article provides a detailed introduction to common sorting algorithms—including bubble, selection, insertion, shell, merge, quick, heap, counting, bucket, and radix sorts—explaining their principles, time complexities, stability, and offering complete Python implementations with step-by-step explanations and visual demonstrations.
ComplexityPythonsorting
0 likes · 21 min read

This article outlines twelve leverage points for system transformation, ranging from simple parameter adjustments to paradigm‑shifting rule changes, and illustrates each with real‑world Chinese policy examples, helping readers choose the most effective intervention for social, economic, or environmental challenges.
ComplexityPolicySystems
0 likes · 12 min read

The article reviews the main ideas of John Ousterhout's *A Philosophy of Software Design* (2nd edition), explaining how the book defines software complexity, proposes strategies such as eliminating or encapsulating complexity, and discusses deep classes, shallow interfaces, naming, strategic versus tactical programming, and practical warnings for developers.
Complexitycode qualitymodular design
0 likes · 14 min read

The article argues that despite AI’s recent breakthroughs, it cannot solve the inherent complexity of software development, and revisits classic software design principles—from modularity and code design to maintenance and performance—presented in John Ousterhout’s “Software Design Philosophy (2nd edition)” as essential guidance for developers.
AIAgileComplexity
0 likes · 9 min read

This article explores eight common system‑thinking traps—such as policy resistance, the tragedy of the commons, goal erosion, and rule avoidance—and offers practical strategies to transform these pitfalls into opportunities for wiser, more holistic decision‑making.
Complexitydecision makingpolicy resistance
0 likes · 12 min read

Mathematical modeling thrives on useful approximations rather than flawless precision, as illustrated by Keynes’s economic insights, Box’s famous quote, and real‑world examples like weather forecasting and epidemic models, showing that simplified, “good enough” models often provide more actionable guidance amid complexity and uncertainty.
ComplexityPragmatismapproximation
0 likes · 5 min read

Drawing on a decade of front‑end experience, the article explains why many developers mistakenly view front‑end work as simple, explores the hidden complexity of modern web technologies, cross‑platform development, and the importance of strong fundamentals, while urging respect for the role.
Complexitycross‑platformfrontend
0 likes · 7 min read

The article explains what software complexity is, classifies its types, describes the negative impacts of high business complexity, identifies common causes, and presents practical methods such as domain decomposition, layered architecture, structured decomposition, annotation, configurability, and coding standards to effectively reduce complexity.
ComplexityConfigurationcode refactoring
0 likes · 13 min read


DevOpsJun 30, 2024 · Fundamentals
This article explores system theory, architectural design, and complexity, presenting a structured view of systems, their characteristics, modeling approaches like 4+1 and C4, microservice concepts, and the Cynefin framework, offering developers practical insights to manage and evolve software systems effectively.
C4 modelComplexityCynefin framework
0 likes · 19 min read

Aliaksandr Valialkin criticizes Go 1.23’s new iterator feature, arguing it adds hidden control‑flow, memory overhead and readability challenges to an already minimalist language, and warns that such complexity undermines Go’s goals of simplicity, productivity, and performance.
ComplexityGenericsGo
0 likes · 9 min read


21CTOJan 25, 2024 · Fundamentals
This article explains how entropy, the broken‑window effect, and accumulated complexity erode software systems, compares behavior and architecture value dimensions, and presents fundamental principles such as Ockham's razor, SOLID, layering, and anti‑corruption layers to build maintainable, low‑cost architectures.
ComplexityDesign PrinciplesSOLID
0 likes · 17 min read

This article explains essential software architecture concepts such as entropy and broken‑window effects, the sources and symptoms of complexity, the importance of orthogonality and consistency, and classic design principles like SOLID, DRY, and layered abstraction to guide architects in building maintainable, flexible systems.
ComplexityDRYDesign Principles
0 likes · 18 min read

The article explains that good software architecture must be deliberately designed and continuously refactored to combat entropy and the broken‑window effect, balancing behavior and architecture value while managing complexity through principles like Ockham’s razor, orthogonality, DRY, stable dependencies, layered abstractions, and clear boundaries, supported by UML visualizations.
ComplexityDRYDesign Principles
0 likes · 19 min read


DevOpsDec 20, 2023 · Frontend Development
This article examines the history, design motivations, and trade‑offs of modern frontend frameworks—covering Svelte’s new runes feature, the rise of component‑based architectures, template abstraction, cross‑platform compilation, and the differing philosophies of React, Vue, and Svelte—to explain why added complexity ultimately improves developer productivity and code maintainability.
ComplexityFrameworksReact
0 likes · 28 min read

The article traces the historical evolution of front‑end frameworks—from static pages and jQuery to modern component‑based libraries like React, Vue, and Svelte—explaining why added complexity and compile‑time features such as Svelte’s runes improve maintainability, reactivity, and cross‑platform capabilities while weighing each framework’s design philosophy and trade‑offs for developers.
ComplexityDesignFrameworks
0 likes · 27 min read

Given two positive integers n and k, construct an array of n distinct numbers whose greatest common divisor is k and whose total sum is as small as possible, then output that minimal sum.
AlgorithmComplexityGCD
0 likes · 5 min read

This article explores why software complexity is inherent, examines cognitive challenges, and presents practical design principles—such as responsibility separation, layered abstraction, and change extensibility—illustrated with real-world examples from Spring MVC, MyBatis, and other frameworks, offering actionable insights for building maintainable systems.
ComplexityJavaarchitecture
0 likes · 19 min read

The article explains that architecture design exists to manage software system complexity, outlines common misconceptions, describes the six sources of complexity and their generic solutions, examines performance, availability, scalability, cost, security and scale concerns, and shows how microservices and Domain‑Driven Design can address these challenges.
ComplexityDDDarchitecture
0 likes · 26 min read

This article combines a light‑hearted Valentine’s Day introduction for programmers with a detailed presentation of the classic Two Sum problem, including problem description, constraints, example inputs and outputs, multiple language implementations, and a complexity analysis.
AlgorithmComplexityGo
0 likes · 7 min read

The article argues that complexity in software systems cannot be eliminated but only shifted, emphasizing the inevitability of leaks, the limits of local consequence, and the practical value of layering and eliminating duplication to make frequent changes easier and code more understandable.
ComplexityDesign Principlescode organization
0 likes · 8 min read

The article argues that complexity in software systems is unavoidable and must be consciously placed, managed, and reduced through thoughtful architectural decisions, prioritizing high‑frequency changes, eliminating duplication, and accepting that perfect local consequences are impossible.
ComplexityDesign Principlescode organization
0 likes · 9 min read

The article argues that complexity is an unavoidable aspect of software development and architecture, urging engineers to acknowledge, manage, and strategically place it rather than trying to eliminate it, while illustrating the trade‑offs in tooling, abstractions, and micro‑service design.
ComplexityDesign Principlesmicroservices
0 likes · 7 min read


DevOpsOct 17, 2022 · Fundamentals
The article explains how the traditional VUCA model has become insufficient for describing today’s chaotic world and introduces the BANI framework—Brittle, Anxious, Nonlinear, Incomprehensible—as a more precise lens for interpreting modern volatility, uncertainty, complexity, and ambiguity.
BANIComplexityFuture Studies
0 likes · 8 min read

The answer breaks down Windows' massive complexity by citing millions of source lines for XP, Vista and 7, the roughly 1,000 engineers across 23 development groups, a detailed team list, the physical scale of its codebase when printed, and snapshots of its file system and registry to illustrate the sheer magnitude to a layperson.
ComplexityWindowscode size
0 likes · 7 min read

This roundup presents a curated list of recent frontend development articles covering Babel 7.18 upgrade issues, TypeScript migration strategies, monitoring system design, JavaScript security techniques, ES2022 features, React Native Skia integration, GraphQL BFF practices, and thoughts on software complexity.
ComplexityElectronGraphQL
0 likes · 5 min read

This article introduces system thinking by defining systems and explaining its three core mindsets—deep, holistic, and dynamic thinking—while detailing causal loop diagram components, common reinforcing and balancing loops, and five foundational models that together help analyze interdependencies, uncover behavior patterns, and support wiser decision‑making.
Complexitybusiness analysiscausal loop
0 likes · 10 min read

The article analyzes why modern software systems repeatedly collapse—due to growing business complexity, unpredictable changes, and architectural decay—and proposes principles such as decentralization, integration, and diversity, along with practical strategies like service mesh and eBPF, to design more sustainable, observable, and self‑evolving architectures.
ComplexityResiliencearchitecture
0 likes · 12 min read

This article explores the nature of software complexity, contrasting tactical programming shortcuts with strategic architectural design, explains McCabe cyclomatic complexity and Ousterhout's perception, and offers practical insights and code examples to help engineers manage and reduce complexity in their systems.
Complexityarchitecturesoftware design
0 likes · 20 min read


21CTOApr 7, 2022 · R&D Management
In an era dominated by black‑swan events and misinformation, the article explores how leaders can develop resilience through humility, first‑principles thinking, revisiting classic research, and collaborative sense‑making to navigate digital transformation and the challenges of a rapidly evolving information landscape.
Complexitydigital transformationfirst principles
0 likes · 10 min read

This article explains the classic maximum subarray problem, presents a brute‑force O(n³) method, an improved O(n²) version, a divide‑and‑conquer O(N log N) algorithm, and a linear‑time O(N) dynamic‑programming solution, each with full C++ code and complexity analysis.
C++ComplexityDivide and Conquer
0 likes · 8 min read

This article provides a comprehensive overview of fundamental data structures and algorithms, covering basic concepts, complexity analysis, case studies, and detailed examinations of structures such as HashMap, Bloom filter, SkipList, AVL, Red‑Black, B+Tree, and HashTree, while discussing their advantages, disadvantages, and typical use cases.
AVL TreeComplexityHashMap
0 likes · 23 min read

The article explains why high‑quality code boosts product and developer success, lists practical practices such as style standards, meaningful naming, testing, CI, reviews and pair programming, and recommends tackling improvements in three stages—first delivering business functionality, then enhancing readability, and finally reducing complexity.
Best PracticesComplexityContinuous Integration
0 likes · 5 min read

This comprehensive guide walks Java programmers through the ten classic sorting algorithms—bubble, quick, insertion, shell, selection, heap, merge, bucket, counting, and radix—detailing their principles, stability, time and space complexities, and providing clear Java implementations for each.
ComplexitySorting Algorithmsalgorithm analysis
0 likes · 21 min read

This article explains heap sort's time and space complexities, introduces max‑heap and min‑heap concepts, details the algorithmic steps for building and maintaining the heap, and provides a complete Java implementation with accompanying code examples.
AlgorithmComplexityJava
0 likes · 8 min read

This article shares the author’s personal insights on a book about algorithms, data structures, and complexity, explaining core concepts such as algorithm definition, common data structures, time and space complexity, and offering intuitive examples to aid understanding.
AlgorithmsComplexitydata structures
0 likes · 12 min read

This article provides a comprehensive overview of data structures and algorithms, covering fundamental concepts such as data, elements, objects, logical and storage structures, common structures like lists, stacks, queues, trees, graphs, algorithm design techniques, complexity analysis, and includes visual resources and code examples.
AlgorithmsComplexityGraph Algorithms
0 likes · 33 min read

This article introduces the core concepts of algorithms, covering their definition, five essential properties, design principles such as correctness and readability, methods for analyzing time and space complexity, common complexity classes, and a variety of algorithmic strategies including recursion, dynamic programming, greedy and divide‑and‑conquer techniques.
AlgorithmComplexityDesign Principles
0 likes · 23 min read

This article provides a comprehensive overview of algorithms, covering their definition, five essential characteristics, design principles, time and space complexity analysis, common complexity classes, and a variety of algorithmic strategies such as recursion, greedy, divide‑and‑conquer, and dynamic programming.
AlgorithmsBig OComplexity
0 likes · 25 min read

The article analyzes how the relentless pursuit of high performance drives both single‑machine and cluster‑level architectural complexity, explaining the evolution from batch processing to multi‑core CPUs, the trade‑offs of processes, threads, SMP/NUMA/MPP, and the challenges of task allocation and decomposition in large‑scale systems.
BackendComplexitydistributed systems
0 likes · 16 min read

The article explores how abstract thinking and complexity influence a product manager's abilities, explains the purpose and timing of creating product architecture diagrams, and provides detailed guidance on different diagram types, their design methods, and practical steps for visualizing product, service, and ecosystem structures.
ComplexityDesign ThinkingProduct Architecture
0 likes · 11 min read

This article explains when to use JavaScript arrays versus objects by describing their memory layout, common operations such as adding, removing, and searching elements, and analyzing each operation's time complexity using Big O notation, while also covering hash collisions and practical performance considerations.
Big OComplexityObjects
0 likes · 12 min read

This article provides a comprehensive introduction to fundamental data structures, core algorithm concepts, and classic sorting techniques, explaining their definitions, basic operations, time and space complexities, stability considerations, and practical use cases for developers seeking to strengthen their programming foundations.
AlgorithmsComplexitybinary tree
0 likes · 20 min read

This article provides a detailed summary of classic sorting algorithms—including insertion, shell, selection, bubble (standard and optimized), counting, merge (recursive and iterative), radix, and bucket sorts—explaining their stability, time complexities, and offering complete C implementations for each.
C++Complexitysorting
0 likes · 12 min read


21CTOJan 3, 2020 · Fundamentals
The article lists twelve danger signals—ranging from shallow modules and information leaks to vague naming and unreadable code—that reveal hidden complexity in software design and help developers identify and refactor problematic patterns.
Complexityanti-patternscode quality
0 likes · 6 min read

This article provides a comprehensive overview of eight classic sorting algorithms—including bubble sort, quick sort, insertion sort, shell sort, selection sort, heap sort, merge sort, and radix sort—detailing their core ideas, Java implementations, performance characteristics, space usage, and stability considerations.
ComplexityQuick Sortbubble sort
0 likes · 30 min read


21CTOAug 23, 2019 · Fundamentals
Object-oriented programming, once hailed as the pinnacle of software design, is criticized for its complexity, mutable state, and poor testability, while functional programming offers simpler, more reliable code through immutability and pure functions, prompting a call to abandon OOP in favor of functional paradigms.
ComplexityOOPProgramming Paradigms
0 likes · 29 min read

This article explores how transformational leadership addresses complexity, ambiguity, and uncertainty by introducing Ralph Stacey’s complexity matrix and outlining practical steps leaders can take to empower performance and navigate chaotic business environments.
ComplexityStacey matrixtransformational leadership
0 likes · 5 min read

This article provides a detailed, step‑by‑step walkthrough of ten widely used sorting algorithms—including bubble, selection, insertion, shell, merge, quick, heap, counting, bucket, and radix sorts—explaining their principles, visualizing each pass, analyzing time and space complexities, and presenting complete Java code examples for every method.
ComplexityJavaSorting Algorithms
0 likes · 33 min read

This article explains how software complexity arises from both business requirements and quality attributes, discusses the challenges of technical and business complexity, and demonstrates how Domain‑Driven Design—through layered and hexagonal architectures, bounded contexts, and micro‑service decomposition—helps isolate concerns and manage complexity in large systems.
ComplexityLayered Architecturedomain-driven design
0 likes · 24 min read

This article provides a detailed introduction to sorting algorithms, covering internal and external sorts, their time complexities and stability characteristics, and presents step‑by‑step Java implementations for bubble sort, selection sort, insertion sort, shell sort, merge sort, quick sort, heap sort, counting sort, bucket sort, and radix sort, accompanied by visual illustrations.
Complexitydata structuressorting
0 likes · 21 min read

This article explains the performance characteristics and implementation details of common linear data structures such as arrays, hash maps, sets, lists, linked lists, stacks, and queues, showing their time complexities, code examples, and how to choose the right structure for efficient programming.
ComplexityHashMapJavaScript
0 likes · 50 min read

This article presents concise explanations for 18 common algorithm interview questions, covering definitions, sorting methods, time‑complexity notation, search techniques, data structures, encryption basics, and the differences between best‑case and worst‑case scenarios.
AlgorithmsComplexityInterview
0 likes · 9 min read

The article critically examines micro‑services, outlining their promised benefits such as independent development, deployment and scaling, while exposing the hidden operational, dev‑ops, state‑management, communication, versioning and distributed‑transaction challenges that can turn them into a fragile, overly complex system.
Complexitydistributed systemsmicroservices
0 likes · 15 min read

The article discusses how expert programmers must continuously learn and balance humility with confidence, explores the end‑to‑end design principle, examines complexity, layering, and componentization in large systems, and highlights performance considerations, distributed‑system realities, and management lessons for building robust software.
Complexitydistributed systemsmanagement
0 likes · 20 min read


ITPUBMay 2, 2017 · Fundamentals
This guide presents concise explanations of essential algorithms—including quick sort, merge sort, bucket and radix sorts, depth‑first and breadth‑first searches, shortest‑path and minimum‑spanning‑tree methods—along with their stability, time‑complexity analyses, greedy strategies, bit‑manipulation tricks, and asymptotic notation, and points to a GitHub repository for reference implementations.
AlgorithmsComplexityGraph
0 likes · 10 min read


ITPUBApr 24, 2017 · Fundamentals
This article provides a concise reference of core algorithms—including sorting methods, graph traversals, shortest‑path techniques, greedy strategies, bit‑level manipulations, and asymptotic notation—detailing their stability, time complexities, key concepts, and practical examples for interview preparation.
AlgorithmsComplexityGraph Algorithms
0 likes · 8 min read

This article explains the classic 0/1 knapsack problem, presents a detailed dynamic programming approach with step‑by‑step table construction, demonstrates the method using a concrete example, and discusses its computational complexity.
AlgorithmComplexitydynamic programming
0 likes · 7 min read
