BestHub
Sign in
Tagged articles

Complexity

66 articles · Page 1 of 1
AI Large-Model Wave and Transformation Guide
AI Large-Model Wave and Transformation Guide
Aug 9, 2026 · Artificial Intelligence

Why Ontology Can Be More Precise Than RAG While Requiring Less Engineering Effort?

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
Why Ontology Can Be More Precise Than RAG While Requiring Less Engineering Effort?
samdeepthink
samdeepthink
Aug 7, 2026 · Frontend Development

Why Backend Engineers Mistake Frontend for Simple—and What That Reveals

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.

ComplexityFrontendSoftware Engineering
0 likes · 4 min read
Why Backend Engineers Mistake Frontend for Simple—and What That Reveals
Programmer1970
Programmer1970
May 12, 2026 · Backend Development

Are Microservices a Nightmare for Small Teams?

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
Are Microservices a Nightmare for Small Teams?
High Availability Architecture
High Availability Architecture
Dec 26, 2025 · Artificial Intelligence

Why AI-Generated Code Threatens Understanding: A Netflix Engineer’s Three‑Stage Method

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.

AIComplexityContext Compression
0 likes · 20 min read
Why AI-Generated Code Threatens Understanding: A Netflix Engineer’s Three‑Stage Method
IT Architects Alliance
IT Architects Alliance
Oct 24, 2025 · Cloud Native

Balancing Flexibility and Complexity: Strategies for Modern Architecture

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.

Complexityarchitecturecloud-native
0 likes · 11 min read
Balancing Flexibility and Complexity: Strategies for Modern Architecture
Software Engineering 3.0 Era
Software Engineering 3.0 Era
Jun 10, 2025 · Fundamentals

Why Most Miss the Core of Software Engineering: A First‑Principles Exploration

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.

AutomationComplexitySoftware Engineering
0 likes · 10 min read
Why Most Miss the Core of Software Engineering: A First‑Principles Exploration
php Courses
php Courses
May 9, 2025 · Fundamentals

Detecting Duplicate Elements in an Array Using PHP

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
Detecting Duplicate Elements in an Array Using PHP
php Courses
php Courses
Apr 2, 2025 · Fundamentals

Implementing a Queue Using Two Stacks in PHP

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.

AlgorithmComplexityData Structure
0 likes · 5 min read
Implementing a Queue Using Two Stacks in PHP
Python Programming Learning Circle
Python Programming Learning Circle
Feb 21, 2025 · Fundamentals

Comprehensive Overview of Common Sorting Algorithms with Python Implementations

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
Comprehensive Overview of Common Sorting Algorithms with Python Implementations
Model Perspective
Model Perspective
Dec 6, 2024 · Fundamentals

12 Leverage Points to Transform Complex Systems—from Parameters to Paradigms

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.

ComplexitySystemsleverage points
0 likes · 12 min read
12 Leverage Points to Transform Complex Systems—from Parameters to Paradigms
Smart Era Software Development
Smart Era Software Development
Dec 6, 2024 · Fundamentals

Key Takeaways from A Philosophy of Software Design (2nd Edition)

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.

ComplexityModular DesignSoftware Design
0 likes · 14 min read
Key Takeaways from A Philosophy of Software Design (2nd Edition)
Programmer DD
Programmer DD
Dec 5, 2024 · Fundamentals

Why AI Isn’t a Silver Bullet: Core Software Design Principles Revealed

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.

AIComplexitySoftware Design
0 likes · 9 min read
Why AI Isn’t a Silver Bullet: Core Software Design Principles Revealed
Model Perspective
Model Perspective
Nov 28, 2024 · Fundamentals

How to Outsmart Decision Traps: Mastering Systemic Thinking

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.

ComplexitySystems Thinkingdecision making
0 likes · 12 min read
How to Outsmart Decision Traps: Mastering Systemic Thinking
Model Perspective
Model Perspective
Oct 21, 2024 · Fundamentals

Why “Good Enough” Models Beat Perfect Ones: Insights from Economics & Weather

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.

ComplexityPragmatismUncertainty
0 likes · 5 min read
Why “Good Enough” Models Beat Perfect Ones: Insights from Economics & Weather
IT Services Circle
IT Services Circle
Sep 16, 2024 · Frontend Development

Is Frontend Development Really Simple? A Ten‑Year Perspective

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.

ComplexityFrontendcross‑platform
0 likes · 7 min read
Is Frontend Development Really Simple? A Ten‑Year Perspective
JD Tech
JD Tech
Sep 5, 2024 · Fundamentals

Overview of System Complexity and Strategies for Reducing Business Complexity

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.

Code RefactoringComplexityConfiguration
0 likes · 13 min read
Overview of System Complexity and Strategies for Reducing Business Complexity
DevOps
DevOps
Jun 30, 2024 · Fundamentals

Understanding Systems, Architecture, and Complexity: A Comprehensive Overview

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
Understanding Systems, Architecture, and Complexity: A Comprehensive Overview
21CTO
21CTO
Jan 25, 2024 · Fundamentals

Why Software Architecture Fails: Entropy, Broken Windows, and Sustainable Design

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
Why Software Architecture Fails: Entropy, Broken Windows, and Sustainable Design
Architect
Architect
Jan 25, 2024 · Fundamentals

Key Principles of Software Architecture: Entropy, Broken Windows, Complexity, SOLID, and Design Strategies

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
Key Principles of Software Architecture: Entropy, Broken Windows, Complexity, SOLID, and Design Strategies
Tencent Cloud Developer
Tencent Cloud Developer
Dec 21, 2023 · Fundamentals

Software Architecture Design: Principles, Complexity, and Best Practices

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
Software Architecture Design: Principles, Complexity, and Best Practices
DevOps
DevOps
Dec 20, 2023 · Frontend Development

Understanding the Evolution, Complexity, and Design Philosophy of Frontend Frameworks

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.

ComplexityFrameworksFrontend
0 likes · 28 min read
Understanding the Evolution, Complexity, and Design Philosophy of Frontend Frameworks
Tencent Cloud Developer
Tencent Cloud Developer
Dec 5, 2023 · Frontend Development

Understanding the Evolution, Design, and Complexity of Modern Front-End Frameworks

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.

ComplexityFrameworksFrontend
0 likes · 27 min read
Understanding the Evolution, Design, and Complexity of Modern Front-End Frameworks
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 6, 2023 · Fundamentals

Mastering Software Complexity: Design Principles and Real-World Patterns

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.

ComplexitySoftware Designarchitecture
0 likes · 19 min read
Mastering Software Complexity: Design Principles and Real-World Patterns
dbaplus Community
dbaplus Community
May 31, 2023 · Fundamentals

Why Architecture Design Matters: Tackling System Complexity with Microservices & DDD

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.

ComplexityDDDSoftware Design
0 likes · 26 min read
Why Architecture Design Matters: Tackling System Complexity with Microservices & DDD
Architect
Architect
Oct 30, 2022 · Fundamentals

Managing Complexity in Software Architecture

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.

Code OrganizationComplexityDesign Principles
0 likes · 9 min read
Managing Complexity in Software Architecture
Architect
Architect
Oct 29, 2022 · Fundamentals

Embracing Complexity: Reflections on Software Architecture

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 PrinciplesResilience Engineering
0 likes · 7 min read
Embracing Complexity: Reflections on Software Architecture
DevOps
DevOps
Oct 17, 2022 · Fundamentals

From VUCA to BANI: A New Framework for Understanding Complex Futures

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
From VUCA to BANI: A New Framework for Understanding Complex Futures
Liangxu Linux
Liangxu Linux
Aug 4, 2022 · Fundamentals

How Complex Is Windows? Code Size, Teams, and Architecture Explained

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.

ComplexitySoftware EngineeringWindows
0 likes · 7 min read
How Complex Is Windows? Code Size, Teams, and Architecture Explained
Sensors Frontend
Sensors Frontend
Jul 5, 2022 · Frontend Development

Essential Frontend Articles: Babel 7.18 Issues, TypeScript Migration, Monitoring & JS Security

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.

ComplexityElectronFrontend
0 likes · 5 min read
Essential Frontend Articles: Babel 7.18 Issues, TypeScript Migration, Monitoring & JS Security
DaTaobao Tech
DaTaobao Tech
Jul 4, 2022 · Fundamentals

Introduction to System Thinking

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.

Business AnalysisComplexitySystem thinking
0 likes · 10 min read
Introduction to System Thinking
Laiye Technology Team
Laiye Technology Team
Jun 10, 2022 · Backend Development

Understanding System Failures and Principles for Resilient Architecture

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.

ComplexitySystem Designarchitecture
0 likes · 12 min read
Understanding System Failures and Principles for Resilient Architecture
Alibaba Terminal Technology
Alibaba Terminal Technology
Apr 21, 2022 · Fundamentals

Why Software Complexity Grows: From Tactical Tornadoes to Strategic Design

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.

ComplexitySoftware Designarchitecture
0 likes · 20 min read
Why Software Complexity Grows: From Tactical Tornadoes to Strategic Design
21CTO
21CTO
Apr 7, 2022 · R&D Management

How to Thrive in the Age of Complexity: Insights from Microsoft’s CTO

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
How to Thrive in the Age of Complexity: Insights from Microsoft’s CTO
JD Tech
JD Tech
Mar 8, 2022 · Fundamentals

Fundamentals of Data Structures and Algorithms

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 treeComplexityData Structures
0 likes · 23 min read
Fundamentals of Data Structures and Algorithms
Tencent Cloud Developer
Tencent Cloud Developer
Dec 6, 2021 · Fundamentals

Improving Code Quality: Methods, Priorities, and Stages

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.

Code ReviewComplexitySoftware Engineering
0 likes · 5 min read
Improving Code Quality: Methods, Priorities, and Stages
Su San Talks Tech
Su San Talks Tech
Aug 24, 2021 · Fundamentals

Master the Top 10 Sorting Algorithms in Java: From Bubble to Radix

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.

ComplexityData StructuresSorting Algorithms
0 likes · 21 min read
Master the Top 10 Sorting Algorithms in Java: From Bubble to Radix
Selected Java Interview Questions
Selected Java Interview Questions
Jul 5, 2021 · Fundamentals

Heap Sort: Theory, Steps, and Java Implementation

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.

AlgorithmComplexityData Structures
0 likes · 8 min read
Heap Sort: Theory, Steps, and Java Implementation
FunTester
FunTester
Jun 11, 2021 · Fundamentals

Personal Reflections on Algorithms, Data Structures, and Complexity

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
Personal Reflections on Algorithms, Data Structures, and Complexity
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 24, 2021 · Fundamentals

Master Data Structures & Algorithms: Comprehensive Guide with Visual Tools

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.

AlgorithmsComplexityData Structures
0 likes · 33 min read
Master Data Structures & Algorithms: Comprehensive Guide with Visual Tools
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 15, 2021 · Fundamentals

Mastering Algorithms: Definitions, Design Principles, and Complexity

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
Mastering Algorithms: Definitions, Design Principles, and Complexity
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 14, 2021 · Fundamentals

Mastering Algorithms: Definitions, Design Principles, and Complexity Explained

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
Mastering Algorithms: Definitions, Design Principles, and Complexity Explained
IT Architects Alliance
IT Architects Alliance
Nov 29, 2020 · Backend Development

Why High Performance Makes Software Architecture So Complex—and How to Tame It

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.

Complexitybackenddistributed systems
0 likes · 16 min read
Why High Performance Makes Software Architecture So Complex—and How to Tame It
IT Architects Alliance
IT Architects Alliance
Oct 29, 2020 · Product Management

Thoughts on Abstraction, Complexity, and Designing Product Architecture Diagrams

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 thinkingabstraction
0 likes · 11 min read
Thoughts on Abstraction, Complexity, and Designing Product Architecture Diagrams
Sohu Tech Products
Sohu Tech Products
Oct 14, 2020 · Fundamentals

Understanding JavaScript Arrays and Objects: Operations and Big O Complexity

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.

ArraysBig OComplexity
0 likes · 12 min read
Understanding JavaScript Arrays and Objects: Operations and Big O Complexity
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 12, 2020 · Fundamentals

Unlock Core Data Structures, Algorithms, and Sorting Basics

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.

AlgorithmsComplexityData Structures
0 likes · 20 min read
Unlock Core Data Structures, Algorithms, and Sorting Basics
21CTO
21CTO
Jan 3, 2020 · Fundamentals

12 Warning Signs That Your Software Design Is Growing Too Complex

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.

ComplexitySoftware Designanti-patterns
0 likes · 6 min read
12 Warning Signs That Your Software Design Is Growing Too Complex
Java Captain
Java Captain
Aug 29, 2019 · Fundamentals

Common Sorting Algorithms: Concepts, Implementations, and Complexity Analysis

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
Common Sorting Algorithms: Concepts, Implementations, and Complexity Analysis
21CTO
21CTO
Aug 23, 2019 · Fundamentals

Why Object-Oriented Programming Is Failing and Functional Programming Is the Future

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.

ComplexityFunctional ProgrammingImmutability
0 likes · 29 min read
Why Object-Oriented Programming Is Failing and Functional Programming Is the Future
Java Captain
Java Captain
Jun 12, 2019 · Fundamentals

Comprehensive Guide to Ten Common Sorting Algorithms with Visual Explanations and Java Implementations

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.

ComplexitySorting Algorithmsalgorithm analysis
0 likes · 33 min read
Comprehensive Guide to Ten Common Sorting Algorithms with Visual Explanations and Java Implementations
Continuous Delivery 2.0
Continuous Delivery 2.0
Jan 15, 2019 · Fundamentals

Software Complexity and Domain‑Driven Design: Isolating Business and Technical Concerns

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.

ComplexityDomain-Driven Designlayered architecture
0 likes · 24 min read
Software Complexity and Domain‑Driven Design: Isolating Business and Technical Concerns
Architect's Tech Stack
Architect's Tech Stack
Nov 28, 2018 · Fundamentals

Comprehensive Overview of Common Sorting Algorithms with Java Implementations

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
Comprehensive Overview of Common Sorting Algorithms with Java Implementations
Java Backend Technology
Java Backend Technology
Jan 21, 2018 · Backend Development

Is Microservices Doomed? Uncovering the Hidden Complexities Behind the Hype

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
Is Microservices Doomed? Uncovering the Hidden Complexities Behind the Hype
Architecture Digest
Architecture Digest
Jun 8, 2017 · Fundamentals

Fundamental Principles of System Design, Complexity, and Performance

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.

ComplexitySoftware EngineeringSystem Design
0 likes · 20 min read
Fundamental Principles of System Design, Complexity, and Performance
ITPUB
ITPUB
May 2, 2017 · Fundamentals

Master Core Algorithms: Sorting, Graph Traversal, Greedy & Complexity Basics

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
Master Core Algorithms: Sorting, Graph Traversal, Greedy & Complexity Basics
ITPUB
ITPUB
Apr 24, 2017 · Fundamentals

Essential Algorithm Cheat Sheet: Sorting, Graph, Greedy, and Bit Operations

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
Essential Algorithm Cheat Sheet: Sorting, Graph, Greedy, and Bit Operations