BestHub
Sign in
Tagged articles

Software Architecture

1324 articles · Page 1 of 14
Architect
Architect
Aug 17, 2026 · Operations

Choosing DSH Plugins: From Architecture Layers to Agent Workflows

With a growing ecosystem of DSH plugins—from simple file path helpers to vision toolkits and automation workflows—this article outlines a pragmatic selection order, explains the four architectural layers each plugin touches, and highlights the hidden dependencies, data persistence, permission and failure‑recovery issues you must evaluate before installing.

DSHSoftware Architectureagent workflow
0 likes · 16 min read
Choosing DSH Plugins: From Architecture Layers to Agent Workflows
YiSu Grain
YiSu Grain
Aug 14, 2026 · R&D Management

Day57: How to Extract Scoring Points from Case Questions and Define Quality‑Attribute Scenarios

This guide teaches architects a three‑pass reading method, how to identify quality‑attribute requirements from case statements, build six‑element scenarios, and craft complete, scored answers for exam‑style architecture problems, using a regional medical registration platform example.

Software Architecturecase analysisdesign methodology
0 likes · 24 min read
Day57: How to Extract Scoring Points from Case Questions and Define Quality‑Attribute Scenarios
DaTaobao Tech
DaTaobao Tech
Aug 14, 2026 · R&D Management

Rethinking Collaboration: Insights on Building AI‑Native Teams

The article argues that AI‑driven efficiency gains are limited by fragmented collaboration, proposes a three‑layer "knowledge base + Agent + human" model to replace humans as the sole orchestrators, and details the practical challenges of constructing such knowledge bases in legacy businesses.

AIAI-nativeAgent
0 likes · 20 min read
Rethinking Collaboration: Insights on Building AI‑Native Teams
Continuous Delivery 2.0
Continuous Delivery 2.0
Aug 13, 2026 · Industry Insights

Can AI Fix the Architectural Pitfalls That Are Driving Teams to Quit?

The article enumerates eight common architectural flaws—ranging from microservice over‑splitting to missing automation—that cripple development, inflate cognitive load, and trigger talent loss, and asks whether AI can help resolve these systemic issues.

AI solutionsEngineering ManagementSoftware Architecture
0 likes · 7 min read
Can AI Fix the Architectural Pitfalls That Are Driving Teams to Quit?
Code Farming
Code Farming
Aug 11, 2026 · Backend Development

Can DDD’s Six‑Step Method Rescue a Broken Microservices Architecture?

The article presents a real‑world case of a ride‑hailing system whose microservices became tangled, and shows how applying Domain‑Driven Design—through strategic design, a six‑step refactoring roadmap, tactical four‑layer architecture, and context mapping—can systematically restore clean, business‑driven services.

DDDDomain-Driven DesignRefactoring
0 likes · 6 min read
Can DDD’s Six‑Step Method Rescue a Broken Microservices Architecture?
samdeepthink
samdeepthink
Aug 11, 2026 · Backend Development

Key Principles for Splitting Microservices: Keep Core Apps Independent

The article shares three hard‑learned principles for dividing microservices—isolating core applications, avoiding delivery slowdown as teams grow, and defining service boundaries with concrete examples—illustrating why each rule matters and how it prevents outages.

Software Architecturecore application isolationmicroservices
0 likes · 3 min read
Key Principles for Splitting Microservices: Keep Core Apps Independent
21CTO
21CTO
Aug 10, 2026 · Industry Insights

Why Windows 11’s Weather App Swallows Over 1 GB of RAM

A new report shows that the built‑in Weather app in Windows 11 can consume more than 1 GB of memory, far higher than macOS’s Weather app, due to its WebView2‑based architecture and embedded Chromium engine, which burdens low‑end PCs with heavy RAM usage.

ChromiumDesktop performanceMemory usage
0 likes · 6 min read
Why Windows 11’s Weather App Swallows Over 1 GB of RAM
DeepNoMind
DeepNoMind
Aug 8, 2026 · Fundamentals

Stop Chasing Frameworks: Master These 7 Architecture Patterns First

This article breaks down seven practical software‑architecture patterns—Bounded Context, Sidecar, Publisher‑Subscriber, Application Gateway, Microservices, Micro‑frontends, and CQRS/Event Sourcing—showing how they can be combined in a real e‑commerce system and guiding architects on when each pattern best solves complexity, performance, or team‑collaboration challenges.

CQRSDesign PatternsSoftware Architecture
0 likes · 17 min read
Stop Chasing Frameworks: Master These 7 Architecture Patterns First
Tencent Technical Engineering
Tencent Technical Engineering
Aug 7, 2026 · Artificial Intelligence

From AI Gibberish to Precise Code Changes: How I Made AI Understand a Legacy Project

The article details a year‑long effort to transform a heavily indebted legacy web platform into an AI‑maintainable system by building explicit AI context, pruning dead code, simplifying architecture, establishing standards, and automating tests, ultimately reducing developer overhead and improving release stability.

AIAutomation TestingContext Engineering
0 likes · 19 min read
From AI Gibberish to Precise Code Changes: How I Made AI Understand a Legacy Project
Fun with Large Models
Fun with Large Models
Aug 4, 2026 · Artificial Intelligence

DeepAgents Code Command System – Full Guide to Production‑Ready Agent Commands

This article dissects DeepAgents Code’s command architecture, explaining the five‑layer framework, slash‑command registration, priority handling via BypassTier, skill and startup commands, and the engineering safeguards that balance interaction efficiency with system safety in production‑grade AI agents.

AI AgentsDeepAgentsLangChain
0 likes · 24 min read
DeepAgents Code Command System – Full Guide to Production‑Ready Agent Commands
TechVision Expert Circle
TechVision Expert Circle
Aug 3, 2026 · Artificial Intelligence

Designing an AI Auto‑Programming System That Outpaces Junior Developers

This article dissects how to build a production‑grade AI auto‑programming system—covering the tasks junior developers spend their time on, a four‑layer architecture, core modules, model tiering, context engineering, toolchain integration, multi‑stage quality checks, and current limitations.

AI programmingContext EngineeringLarge Language Models
0 likes · 15 min read
Designing an AI Auto‑Programming System That Outpaces Junior Developers
YiSu Grain
YiSu Grain
Jul 29, 2026 · Fundamentals

45‑Minute Review: Master the Eight Architecture Types for the Soft Exam

This article guides readers through a 45‑minute review of the eight architecture categories—information‑system, layered, cloud‑native, SOA, embedded, communication, security, and big‑data—showing how to identify the relevant type from a problem statement, combine multiple architectures in a solution, and articulate the problem, solution, rationale, and cost with concrete examples and tables.

Big DataSOASoftware Architecture
0 likes · 32 min read
45‑Minute Review: Master the Eight Architecture Types for the Soft Exam
AI Engineer Programming
AI Engineer Programming
Jul 28, 2026 · Artificial Intelligence

Control State vs Data State in AI Agents: From Turing Machines to LangGraph

This article explains the distinction between control state and data state in AI agent frameworks, tracing the concept from Turing machines through operating systems, databases, and compilers, and shows how LangGraph separates these states via a three‑layer architecture, code examples, and design guidelines.

AI AgentsLangGraphSoftware Architecture
0 likes · 13 min read
Control State vs Data State in AI Agents: From Turing Machines to LangGraph
samdeepthink
samdeepthink
Jul 25, 2026 · Backend Development

Do You Need Strong Coding Skills to Be an Effective Architect?

The author argues that, in most cases, a software architect must possess solid coding abilities because architecture decisions are validated through implementation, and without hands‑on coding the design often fails to meet real‑world constraints.

Software ArchitectureSystem Designbackend development
0 likes · 4 min read
Do You Need Strong Coding Skills to Be an Effective Architect?
samdeepthink
samdeepthink
Jul 24, 2026 · Industry Insights

How Should Companies Hire Programmers in the AI Era?

The article argues that as AI takes over most business code, hiring will shift from pure coding tests to evaluating system‑design skills and the ability to collaborate with AI, emphasizing decision‑making over rote implementation.

AIAI collaborationSoftware Architecture
0 likes · 5 min read
How Should Companies Hire Programmers in the AI Era?
IT Learning Made Simple
IT Learning Made Simple
Jul 23, 2026 · Fundamentals

50 Essential Architecture Concepts in One Sentence Each

This article presents 50 concise statements that cover core software architecture concepts, including fundamentals, types, views, design principles, practical practices, distributed architecture basics, and the mindset needed for architects, providing a quick reference for beginners.

Design PrinciplesSoftware Architecturearchitect mindset
0 likes · 10 min read
50 Essential Architecture Concepts in One Sentence Each
Shuge Unlimited
Shuge Unlimited
Jul 23, 2026 · Artificial Intelligence

Matt Pocock’s Three Skills: Four Core Terms and a Decision Table to Prompt Agents to Ask the Right Questions

The article breaks down Matt Pocock’s three Agent‑skills—codebase‑design, prototype, and improve‑codebase‑architecture—introduces four precise vocabulary items (deep module, seam, locality, leverage), shows how to use a decision table to steer agents toward the right problem definition, and warns about common pitfalls and token costs.

AI AgentsPrototypeSoftware Architecture
0 likes · 18 min read
Matt Pocock’s Three Skills: Four Core Terms and a Decision Table to Prompt Agents to Ask the Right Questions
IT Learning Made Simple
IT Learning Made Simple
Jul 22, 2026 · Fundamentals

Architect’s Reading List: From Beginner to Master

This article presents a curated reading list for software architects, organized by career stages and covering design patterns, code quality, architecture, distributed systems, cloud‑native topics, along with reading principles, recommendations, and a top‑10 book ranking to guide continuous learning.

Design PatternsSoftware Architecturebook list
0 likes · 10 min read
Architect’s Reading List: From Beginner to Master
Linyb Geek Road
Linyb Geek Road
Jul 22, 2026 · R&D Management

From Spec to Production: A 24‑Week Harness Engineering Playbook

The article explains how to turn a well‑written spec into reliable AI‑driven code by introducing Harness Engineering’s five‑layer architecture, five precise human‑intervention moments, three‑tier third‑party documentation, and a detailed 24‑week rollout plan that boosts success rates and reduces release failures.

AI automationCI/CDSoftware Architecture
0 likes · 12 min read
From Spec to Production: A 24‑Week Harness Engineering Playbook
YiSu Grain
YiSu Grain
Jul 20, 2026 · R&D Management

Day 28 Architecture Design Review: From Quality Attribute Scenarios to an ATAM Case Study

This article links the six previous days of architecture training into a complete reasoning chain, applies it to a city‑wide emergency command platform case, and walks through stakeholder analysis, quality‑attribute scenarios, architectural decisions, 4+1 view modeling, ATAM evaluation, and scoring guidance.

4+1 viewATAMSoftware Architecture
0 likes · 18 min read
Day 28 Architecture Design Review: From Quality Attribute Scenarios to an ATAM Case Study
samdeepthink
samdeepthink
Jul 20, 2026 · Fundamentals

Good Architecture Means Cutting Components, Not Adding More

The article argues that seasoned developers improve system architecture by removing unnecessary components—such as redundant Redis caches or message queues—rather than continuously adding new ones, because each addition raises complexity and maintenance overhead, while simpler designs are easier to manage and evolve.

Message QueueRedisSoftware Architecture
0 likes · 3 min read
Good Architecture Means Cutting Components, Not Adding More
YiSu Grain
YiSu Grain
Jul 19, 2026 · Fundamentals

From Requirements to Decisions: Why Architecture Design Isn’t Just Drawing Boxes

The article explains a systematic architecture design method that starts from business goals, functional requirements, quality attributes, and constraints, extracts architecture‑driving factors, applies ABSD or ADD processes, maps components and interfaces, and records decisions with clear rationale and trade‑offs, illustrated with an internet‑hospital case study.

ABSDADDSoftware Architecture
0 likes · 18 min read
From Requirements to Decisions: Why Architecture Design Isn’t Just Drawing Boxes
IT Learning Made Simple
IT Learning Made Simple
Jul 17, 2026 · Fundamentals

How to Evaluate an Architecture: The Five Key Dimensions

The article presents a systematic framework for objectively assessing software architectures across five dimensions—functionality, quality, cost, risk, and team capability—detailing specific metrics, evaluation methods, scoring tables, and a practical workflow to guide informed architectural decisions.

Evaluation FrameworkSoftware Architecturearchitecture evaluation
0 likes · 10 min read
How to Evaluate an Architecture: The Five Key Dimensions
YiSu Grain
YiSu Grain
Jul 17, 2026 · Fundamentals

Day 25 – Five Classic Software Architecture Styles: Focus on System Organization

This article introduces the five classic software architecture styles—data‑flow, call/return, data‑centric, virtual‑machine, and independent component—explaining their core mechanisms, advantages, drawbacks, real‑world examples, and a five‑step method for selecting the appropriate style in system design and exams.

Rule EngineSoftware Architecturearchitecture styles
0 likes · 28 min read
Day 25 – Five Classic Software Architecture Styles: Focus on System Organization
YiSu Grain
YiSu Grain
Jul 17, 2026 · Fundamentals

Day 24: Beyond Speed, Stability, and Security – Defining Quality Requirements with Six Elements

The article explains why vague quality goals like "fast, stable, secure" are insufficient for architecture design and shows how to turn them into measurable quality‑attribute scenarios using six fixed elements—stimulus source, stimulus, environment, artifact, response, and response metric—illustrated with concrete healthcare system examples.

Software Architectureavailabilitymodifiability
0 likes · 18 min read
Day 24: Beyond Speed, Stability, and Security – Defining Quality Requirements with Six Elements
IT Learning Made Simple
IT Learning Made Simple
Jul 16, 2026 · R&D Management

Architecture Rot: How Code Degenerates from "Sweet" to "Beast"

The article defines Architecture Rot as the gradual decay of system design, outlines its four stages—healthy, debt accumulation, degradation, and crisis—details code‑level symptoms, business and technical causes, quantitative detection metrics, and presents a step‑by‑step governance plan including prevention, regular health checks, and incremental refactoring using the strangler‑fig pattern.

RefactoringSoftware Architecturearchitecture
0 likes · 11 min read
Architecture Rot: How Code Degenerates from "Sweet" to "Beast"
YiSu Grain
YiSu Grain
Jul 15, 2026 · R&D Management

From Tech Terms to Real Architecture Design: Day22‑Day42 Learning Roadmap

After completing the first 21 days of foundational topics, the second stage (Day22‑Day42) shifts focus to core architecture design, covering stakeholders, requirements, trade‑offs, evaluation methods, and a detailed daily syllabus that guides learners from theory to practical system design.

Learning RoadmapSoftware ArchitectureSystem Design
0 likes · 12 min read
From Tech Terms to Real Architecture Design: Day22‑Day42 Learning Roadmap
ITPUB
ITPUB
Jul 11, 2026 · R&D Management

Why Top Tech Leaders Always Think One Step Ahead

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.

Software Architecturecomplexity managementrisk mitigation
0 likes · 7 min read
Why Top Tech Leaders Always Think One Step Ahead
Yumin Fish Harvest
Yumin Fish Harvest
Jul 10, 2026 · Fundamentals

Prioritizing DDD Modeling: Focus on Domains, Subdomains, and Core Domains

This chapter explains how to strategically allocate modeling effort in a DDD project by distinguishing domains, subdomains, core, supporting, and generic subdomains, using the “Preferred Store” case to illustrate which areas merit detailed modeling and which can remain simple, ultimately guiding resource focus and decision‑making.

Core DomainDomain-Driven DesignSoftware Architecture
0 likes · 8 min read
Prioritizing DDD Modeling: Focus on Domains, Subdomains, and Core Domains
Yumin Fish Harvest
Yumin Fish Harvest
Jul 10, 2026 · Backend Development

Why Traditional Service Layers Fail and How DDD Restores Order

The article shows how a typical three‑layer OrderService accumulates scattered business rules, mixes technical details with domain logic, lacks clear boundaries, and diverges from business language, then explains how Domain‑Driven Design reorganizes code around aggregates and bounded contexts to solve these problems while outlining when DDD is unnecessary.

DDDDomain-Driven DesignJava
0 likes · 11 min read
Why Traditional Service Layers Fail and How DDD Restores Order
Liangxu Linux
Liangxu Linux
Jul 9, 2026 · Industry Insights

Evaluating the Programming Prowess of Digimon’s Kōshi (Quán Guangzilang)

The article dissects the fictional Digimon character Kōshi’s extraordinary feats—firmware reverse‑engineering, real‑time voice networking, and system‑level analysis—contrasting them with real‑world hardware limits and knowledge breadth to illustrate both the mythic tech hero image and its inspirational impact.

DDoSDigimonSoftware Architecture
0 likes · 8 min read
Evaluating the Programming Prowess of Digimon’s Kōshi (Quán Guangzilang)
Infinite Tech Management
Infinite Tech Management
Jul 8, 2026 · Backend Development

Why “UserService” Is a Bad Name: Lessons from a 12,000‑Line Service

The article recounts a 12,000‑line UserService.java file, explains how the overly generic name masks multiple responsibilities, violates the single‑responsibility principle, and creates a distributed monolith, then shows how domain‑driven naming and bounded‑context splitting can restore clear architecture.

Domain-Driven DesignSingle Responsibility PrincipleSoftware Architecture
0 likes · 8 min read
Why “UserService” Is a Bad Name: Lessons from a 12,000‑Line Service
IT Learning Made Simple
IT Learning Made Simple
Jul 8, 2026 · R&D Management

Tech Selection: The Architect’s Soul‑Searching Moment and How to Choose Wisely

The article explains why technology selection is a daily, critical task for architects, outlines common scenarios such as choosing languages, databases, caches, and messaging systems, presents a step‑by‑step decision‑making process with criteria, weighting, scoring tables, highlights typical pitfalls, and offers practical guidelines to make informed, demand‑driven choices.

Risk ManagementSoftware Architecturedecision making
0 likes · 10 min read
Tech Selection: The Architect’s Soul‑Searching Moment and How to Choose Wisely
samdeepthink
samdeepthink
Jul 8, 2026 · Industry Insights

When to Build Extensibility Early? Three Scenarios That Justify It

The article argues that early extensibility design should be driven by concrete industry certainty—such as established multi-system integration patterns, clear product roadmaps, or repeated historical changes—rather than speculative future needs, illustrating the approach with chain-store integrations, payment channels, and marketing rules.

Design PatternsExtensibilitySoftware Architecture
0 likes · 8 min read
When to Build Extensibility Early? Three Scenarios That Justify It
Tinker Programmer
Tinker Programmer
Jul 8, 2026 · Backend Development

10 Common DDD Mistakes and How to Avoid Them

This article reviews ten frequent misuses of Domain‑Driven Design—ranging from over‑engineering simple CRUD apps to misusing layers, aggregates, services, repositories, and events—provides concrete counter‑examples, explains why they happen, and offers practical corrective guidelines plus a self‑check checklist.

DDDDomain modelingJava
0 likes · 18 min read
10 Common DDD Mistakes and How to Avoid Them
samdeepthink
samdeepthink
Jul 6, 2026 · Fundamentals

Why Object‑Oriented Programming Manages Dependencies, Not Objects

The article argues that true object‑oriented design is about controlling software dependencies, tracing its historical roots from Simula to Smalltalk and C++, illustrating how polymorphism, composition, and proper dependency inversion solve real‑world problems while warning against over‑engineered OO patterns.

Dependency ManagementDesign PatternsSoftware Architecture
0 likes · 15 min read
Why Object‑Oriented Programming Manages Dependencies, Not Objects
Subtle Storm
Subtle Storm
Jul 5, 2026 · R&D Management

System Analyst vs Architecture Designer: Which Path Suits You Best?

The article compares the roles of system analyst and architecture designer, detailing their distinct responsibilities in a large‑scale banking loan system, required skills, exam focus, ideal candidate profiles, and career trajectories to help professionals choose the right path.

Software Architecturecareer-developmentrequirements engineering
0 likes · 6 min read
System Analyst vs Architecture Designer: Which Path Suits You Best?
Architecture and Beyond
Architecture and Beyond
Jul 5, 2026 · Artificial Intelligence

Why Session‑First and Agent‑First Are Different, Not Better or Worse

The article analyses the Session‑First and Agent‑First paradigms for AI‑enabled software, outlining how Session‑First hides complexity in long chat sessions for rapid product launch, while Agent‑First restructures systems around autonomous agents with explicit APIs, documentation, security and observability, and advises when each approach is appropriate.

AI system designAgent EngineeringAgent First
0 likes · 24 min read
Why Session‑First and Agent‑First Are Different, Not Better or Worse
Architect
Architect
Jul 3, 2026 · Artificial Intelligence

Avoiding Skill Hell: Writing Agent Skills That Remain Predictable, Not Outdated Wikis

The article analyses the emerging "Skill Hell" problem where an ever‑growing set of Agent Skills makes routing, context handling, execution and maintenance fragile, and proposes a three‑layer design, explicit routing contracts, progressive disclosure, evidence‑driven steps and disciplined pruning to keep skills stable and auditable.

AI governanceAgent SkillsLLM Ops
0 likes · 26 min read
Avoiding Skill Hell: Writing Agent Skills That Remain Predictable, Not Outdated Wikis
IT Learning Made Simple
IT Learning Made Simple
Jul 3, 2026 · Fundamentals

Understanding the Development View: A Floor‑Plan for Code Organization

The article explains the Development View— the "code floor plan" in the 4+1 view model—by detailing how code is organized, directory structures, module dependencies, build and packaging configurations, common architectural patterns, design principles, and practical solutions to typical problems such as circular dependencies and package chaos.

Code OrganizationDesign PrinciplesOnion Architecture
0 likes · 9 min read
Understanding the Development View: A Floor‑Plan for Code Organization
Subtle Storm
Subtle Storm
Jul 2, 2026 · R&D Management

How to Gracefully Transition from Programmer to Architect

The article explains that moving from programmer to architect requires shifting focus from isolated code elegance to system‑wide thinking, mastering trade‑offs, learning from production incidents, broadening technical breadth, and communicating designs in business terms, offering a step‑by‑step roadmap for the transition.

Software ArchitectureSystem Designcareer-development
0 likes · 6 min read
How to Gracefully Transition from Programmer to Architect
Architectural Methodology
Architectural Methodology
Jun 30, 2026 · Backend Development

From MVC Three‑Layer to DDD Four‑Layer: How Layered Architecture Evolves

Facing a large version release that made the existing MVC three‑layer system hard to maintain, the author outlines the shortcomings of thin entity models, scattered service logic, and code bloat, then presents a DDD‑based four‑layer architecture with domain‑driven design, DIP, and CQRS to improve cohesion, reduce complexity, and support long‑term evolution.

DDDDomain-Driven DesignMVC
0 likes · 11 min read
From MVC Three‑Layer to DDD Four‑Layer: How Layered Architecture Evolves
IT Learning Made Simple
IT Learning Made Simple
Jun 30, 2026 · Fundamentals

Understanding the Logical View: Abstracting What a System Does

The logical view, the first and most intuitive part of the 4+1 view model, describes a system from a functional perspective, compares it with development, process, and physical views, defines core elements such as modules, responsibilities and relationships, outlines design principles, drawing steps, common pitfalls, and documentation templates.

4+1 view modelModule DesignSoftware Architecture
0 likes · 7 min read
Understanding the Logical View: Abstracting What a System Does
IT Learning Made Simple
IT Learning Made Simple
Jun 29, 2026 · Fundamentals

Understanding the 4+1 View Model: Five Perspectives to Master Software Architecture

The article explains why a single architectural view is insufficient, introduces the 4+1 view model by Philippe Kruchten, details each of the five views with their questions, stakeholders, and typical diagrams, and provides practical steps, documentation guidance, and pros and cons for applying the model.

4+1 view modelSoftware ArchitectureSystem Modeling
0 likes · 8 min read
Understanding the 4+1 View Model: Five Perspectives to Master Software Architecture
James' Growth Diary
James' Growth Diary
Jun 29, 2026 · Artificial Intelligence

How WorkBuddy’s Expert Mode Turns Prompts into an AI Harness – 10‑Layer Architecture Explained

The article dissects WorkBuddy’s Expert Mode, showing how it transforms cumbersome, hand‑crafted prompts into a modular, installable AI harness through a ten‑layer architecture of Rules, Expert Prompts, Skills, Tools, Memory, Sub‑Agents and automation, enabling reusable, configurable expert capabilities across models.

AIExpert ModePrompt Engineering
0 likes · 17 min read
How WorkBuddy’s Expert Mode Turns Prompts into an AI Harness – 10‑Layer Architecture Explained
IT Learning Made Simple
IT Learning Made Simple
Jun 28, 2026 · Backend Development

Why Monoliths Shine Early but Become a Fatal Bottleneck Later

The article explains why monolithic architecture is the optimal choice for early‑stage, low‑traffic projects due to its speed, simplicity, and low overhead, but later suffers from release coupling, resource contention, and team conflicts, outlining clear criteria for when to migrate to microservices.

Software Architecturedeploymentmicroservices
0 likes · 3 min read
Why Monoliths Shine Early but Become a Fatal Bottleneck Later
Architect
Architect
Jun 27, 2026 · Backend Development

From Task Cycles to a Maintainable, Observable, Replayable Agent Loop

The article explains how Loop Engineering turns multi‑round Agent execution into a maintainable, observable, and replayable closed‑loop by defining six core components, reusing traditional development patterns, presenting a CI‑failure triage demo, and highlighting architectural and practical pitfalls.

Agent LoopCI pipelineObservability
0 likes · 19 min read
From Task Cycles to a Maintainable, Observable, Replayable Agent Loop
liandk
liandk
Jun 25, 2026 · Fundamentals

Proxy Pattern Explained: Code Samples and Real‑World Scenarios

This article introduces the Proxy design pattern, explains its core purpose of controlling access without modifying original classes, illustrates everyday analogies, provides a complete Java static‑proxy implementation with interface, real subject, proxy and test code, and summarizes common use cases and distinctions from decorators.

AOPDesign PatternsDynamic Proxy
0 likes · 5 min read
Proxy Pattern Explained: Code Samples and Real‑World Scenarios
Subtle Storm
Subtle Storm
Jun 25, 2026 · Backend Development

How to Determine If Your System Really Needs to Be Split into Microservices

The article analyzes when microservices add value versus unnecessary complexity, outlining common pain points, team and operational requirements, and a five‑question checklist to help architects decide if breaking a monolith into independent services is justified.

DevOpsSoftware Architecturemicroservices
0 likes · 7 min read
How to Determine If Your System Really Needs to Be Split into Microservices
Architecture Breakthrough
Architecture Breakthrough
Jun 25, 2026 · R&D Management

How to Design System Architecture Diagrams with DDD in the AI Era

The article explains how architects can bridge high‑level platform diagrams and concrete implementation by using DDD‑based module functional diagrams that serve as prompts for AI code generation, avoiding low‑level detail while ensuring domain understanding guides development.

AI Prompt EngineeringArchitecture DiagramDDD
0 likes · 4 min read
How to Design System Architecture Diagrams with DDD in the AI Era
liandk
liandk
Jun 24, 2026 · Fundamentals

Mastering the Facade Pattern: Clear Explanation, Real‑World Scenarios, and Java Code

This article explains the Facade design pattern, illustrates everyday and software scenarios such as hotel front desks and multimedia players, provides a complete Java implementation with subsystem classes, a facade class, and client code, and lists typical business use cases while warning against common misconceptions.

Design PatternsFacade PatternJava
0 likes · 5 min read
Mastering the Facade Pattern: Clear Explanation, Real‑World Scenarios, and Java Code
liandk
liandk
Jun 23, 2026 · Fundamentals

Decorator Pattern Explained: Simple Theory, Real‑World Scenarios, and Java Code

The article introduces the Decorator pattern, explains its purpose of dynamically adding functionality without altering existing classes, illustrates the concept with everyday analogies and a complete Java milk‑tea example, and lists typical use cases and common pitfalls.

Code ExampleDecorator PatternDesign Patterns
0 likes · 5 min read
Decorator Pattern Explained: Simple Theory, Real‑World Scenarios, and Java Code
Architect
Architect
Jun 21, 2026 · Industry Insights

Why Enterprise AI’s New Moat Lies in Real Workflows, Not Code Complexity

The interview with Anthropic CEO Dario Amodei reveals that as AI makes software generation cheap, the real competitive edge for enterprises will shift from code complexity to mastering real‑world workflows, data permissions, governance, and trustworthy execution within customer environments.

AIAgentic EngineeringEnterprise AI
0 likes · 26 min read
Why Enterprise AI’s New Moat Lies in Real Workflows, Not Code Complexity
Java Tech Enthusiast
Java Tech Enthusiast
Jun 19, 2026 · Fundamentals

Why FFmpeg’s Creator, Used by Billions, Lives in Poverty – History & Architecture

FFmpeg, the hidden engine behind every video you watch, was built by a handful of passionate developers who split container and codec layers, reverse‑engineered closed formats, and endured poverty and community conflict, yet their relentless optimization made it the dominant, open‑source multimedia framework worldwide.

FFmpegReverse EngineeringSoftware Architecture
0 likes · 14 min read
Why FFmpeg’s Creator, Used by Billions, Lives in Poverty – History & Architecture
liandk
liandk
Jun 19, 2026 · Fundamentals

Bridge Pattern Explained with Code and Real-World Scenarios

This article introduces the Bridge design pattern, explains its purpose of separating two independent dimensions to reduce class explosion, provides practical real‑world examples, and walks through a complete Java implementation with interface, abstract bridge, concrete classes, and a test driver.

Bridge PatternDesign PatternJava
0 likes · 5 min read
Bridge Pattern Explained with Code and Real-World Scenarios
iQIYI Technical Product Team
iQIYI Technical Product Team
Jun 18, 2026 · Artificial Intelligence

Shifting Quality Gates Left in the AI Era: Agentic Quality Engineering Architecture and Implementation Template

The article explains how AI‑driven development moves bottlenecks from coding to review, testing, and release, arguing that quality gates must be shifted left by encapsulating verification into an Agentic Quality Engineering framework—comprising a Harness runtime, Planner Agent, specialist Subagents, reusable Skills, an evidence bus, and a rule‑based gate engine—while providing concrete contract templates, risk‑based gate levels, and metrics to measure effectiveness.

AIDevOpsRisk Management
0 likes · 12 min read
Shifting Quality Gates Left in the AI Era: Agentic Quality Engineering Architecture and Implementation Template
IT Learning Made Simple
IT Learning Made Simple
Jun 17, 2026 · Industry Insights

Where Do Architects Over 35 Go? Career Paths, Challenges, and Strategies

The article analyzes how software architects aged 35 and above distribute across continued architecture work, management, entrepreneurship, freelancing, and career switches, using recruitment data, case studies, and practical advice to explain why senior architects become more valuable and how they can navigate age‑related challenges.

EntrepreneurshipSoftware Architectureage and salary trends
0 likes · 10 min read
Where Do Architects Over 35 Go? Career Paths, Challenges, and Strategies
liandk
liandk
Jun 16, 2026 · Fundamentals

Builder Pattern Explained: Simple Theory, Real‑World Scenarios & Java Code

This article introduces the Builder design pattern, illustrates its concept with everyday analogies like milk‑tea making, and provides a complete Java example that assembles a computer through step‑by‑step builders, followed by a summary of typical business use cases and a tip on avoiding confusion with the Factory pattern.

Builder PatternDesign PatternsJava
0 likes · 5 min read
Builder Pattern Explained: Simple Theory, Real‑World Scenarios & Java Code
liandk
liandk
Jun 16, 2026 · Fundamentals

Understanding the Abstract Factory Pattern: Theory, Real‑World Scenarios, and Java Code

The article explains how the Abstract Factory pattern creates whole families of related objects—contrasting it with the Factory Method—illustrates practical scenarios such as phone accessories, UI themes, and payment suites, provides step‑by‑step Java code, lists common use cases, and discusses its limitations.

Abstract FactoryDesign PatternsFactory Method
0 likes · 6 min read
Understanding the Abstract Factory Pattern: Theory, Real‑World Scenarios, and Java Code
Code of Duty
Code of Duty
Jun 15, 2026 · Artificial Intelligence

Cursor vs Codex: An Application‑Level Comparison and Insights

The author runs a series of real‑world development tasks with Cursor (Composer 2.5) and Codex (GPT‑5.5) to compare how each agent understands directories, creates files, designs a WeChat lottery mini‑program MVP, generates MySQL schemas, evaluates non‑functional requirements, and reflects on token usage, concluding that Cursor excels in IDE‑centric, structured outputs while Codex shines as a terminal‑based coding agent.

AI coding assistantCodexSoftware Architecture
0 likes · 10 min read
Cursor vs Codex: An Application‑Level Comparison and Insights
samdeepthink
samdeepthink
Jun 14, 2026 · R&D Management

How I Delivered a Sub‑Brand in Three Weeks Amid the Pandemic

During the COVID‑19 lockdown, the CTO demanded that the new sub‑brand’s online systems be completed in three weeks; the author describes asking the boss’s priority, copying the main brand’s code, setting strict weekly milestones, intensive testing, remote coordination, and ultimately delivering on time.

AgileProject ManagementSoftware Architecture
0 likes · 12 min read
How I Delivered a Sub‑Brand in Three Weeks Amid the Pandemic
TechVision Expert Circle
TechVision Expert Circle
Jun 13, 2026 · R&D Management

When AI Can Write Code, Does R&D Management Still Matter?

The article argues that although AI can generate code at unprecedented speed, the core of R&D management shifts from supervising individual developers to safeguarding system architecture, ensuring consistent design, and orchestrating human‑AI collaboration, because accelerated output amplifies systemic risks.

AI codingCI/CDPrompt Engineering
0 likes · 13 min read
When AI Can Write Code, Does R&D Management Still Matter?
liandk
liandk
Jun 13, 2026 · Fundamentals

23 Essential Design Patterns – Complete List with Visuals

This article presents a comprehensive, mobile‑friendly catalog of 23 classic design patterns, organized into Creational, Structural, and Behavioral groups, offering clear names and categories that developers can copy and use as a quick reference for learning and applying design patterns.

BehavioralCreationalDesign Patterns
0 likes · 2 min read
23 Essential Design Patterns – Complete List with Visuals
IT Learning Made Simple
IT Learning Made Simple
Jun 12, 2026 · Industry Insights

How Architects' Roles Differ Between China and Abroad

The article analyzes the contrasting status, daily responsibilities, skill expectations, compensation, career trajectories, and cultural influences of software architects in China versus those in Silicon Valley, highlighting each side's strengths, weaknesses, and suitability for different professionals.

ChinaSilicon ValleySoftware Architecture
0 likes · 11 min read
How Architects' Roles Differ Between China and Abroad
IT Learning Made Simple
IT Learning Made Simple
Jun 11, 2026 · Industry Insights

Why China Needs So Many Software Architects: A Policy‑Driven Analysis

The article examines why China’s digital‑economy strategy, technology‑sovereignty goals, the Xinchuang initiative, widespread digital transformation, and a severe talent gap are driving an unprecedented demand for software architects, and it offers policy‑aware career recommendations.

Software ArchitectureTalent ShortageTechnology Sovereignty
0 likes · 9 min read
Why China Needs So Many Software Architects: A Policy‑Driven Analysis
samdeepthink
samdeepthink
Jun 11, 2026 · Fundamentals

Why Code Reuse Matters When Integrating with Low‑Code Platforms

The article shows how duplicating 20‑40 lines of request‑building code for each low‑code table operation leads to maintenance risk, and demonstrates extracting two generic Java methods that encapsulate invariant logic while parameterising fields, tables, and apps, dramatically reducing code and clarifying responsibilities.

API designDRY principleJava
0 likes · 8 min read
Why Code Reuse Matters When Integrating with Low‑Code Platforms
ZhiKe AI
ZhiKe AI
Jun 11, 2026 · Backend Development

Monolith Isn’t the Problem—It’s the Big Ball of Mud

The article argues that monolithic architecture is not inherently flawed; the real issue is a “big ball of mud” lacking clear module boundaries, and it explains how the MonolithFirst principle, an architecture spectrum, modular‑monolith design rules, and real‑world case studies guide teams to choose the right structure.

Software Architecturecase studymicroservices
0 likes · 13 min read
Monolith Isn’t the Problem—It’s the Big Ball of Mud
IT Learning Made Simple
IT Learning Made Simple
Jun 8, 2026 · R&D Management

The Essential Gear to Become a Software Architect

This guide maps the complete skill tree for aspiring software architects, detailing foundational knowledge, core competencies such as system design and performance tuning, extended expertise in cloud‑native and big‑data technologies, and a staged learning roadmap to help newcomers acquire the necessary gear.

Big DataSoftware ArchitectureSystem Design
0 likes · 9 min read
The Essential Gear to Become a Software Architect
IT Learning Made Simple
IT Learning Made Simple
Jun 7, 2026 · Industry Insights

A Day in the Life of an Architect: Meetings, Diagrams, and Taking the Blame

The article walks through a typical software architect’s day—from early‑morning stand‑ups and requirement reviews, through writing design documents, ad‑hoc incident triage, architecture review meetings, code reviews, and technical‑debt cleanup—highlighting time allocation, required skills, pain points, and practical advice for aspiring architects.

Software ArchitectureSystem Designarchitecture design
0 likes · 9 min read
A Day in the Life of an Architect: Meetings, Diagrams, and Taking the Blame
IT Learning Made Simple
IT Learning Made Simple
Jun 5, 2026 · Industry Insights

Why Senior Architects Command Higher Value: The Aging Advantage in Tech

The article examines why software architects become more valuable with age, contrasting the fleeting, physically demanding nature of coding roles with the experience‑rich, low‑replaceability, decision‑making responsibilities of architecture, and offers concrete steps for engineers to develop the requisite skills.

Software Architecturecareer-developmentdecision making
0 likes · 8 min read
Why Senior Architects Command Higher Value: The Aging Advantage in Tech
ZhiKe AI
ZhiKe AI
Jun 5, 2026 · Fundamentals

Understanding Onion Architecture: Beyond the Concentric Circles

The article explains that Onion Architecture’s essence lies in inward‑facing dependencies rather than the visual onion shape, details its six‑layer structure, clarifies common misconceptions, and compares it with Clean and Hexagonal architectures to show how it improves testability and replaceability.

Clean ArchitectureDependency InversionDomain-Driven Design
0 likes · 12 min read
Understanding Onion Architecture: Beyond the Concentric Circles
IT Learning Made Simple
IT Learning Made Simple
Jun 4, 2026 · Fundamentals

One Diagram That Reveals the Full Software Architecture Family Tree

This article uses a single family‑tree diagram to explain the three generations of software architecture—enterprise, application, and domain‑specific architectures—detailing their layers, typical concerns, common tools, and the 4+1 view model for describing systems from multiple perspectives.

Software ArchitectureTechnical Architectureapplication architecture
0 likes · 7 min read
One Diagram That Reveals the Full Software Architecture Family Tree
Architectural Methodology
Architectural Methodology
Jun 4, 2026 · R&D Management

7 Common Pain Points When Software Engineers Become Architects (And How to Overcome Them)

The article outlines seven typical challenges that software developers face when moving into an architect role, such as over‑focusing on technical details, neglecting non‑functional requirements, poor communication with diverse stakeholders, and failing to design for failure, and suggests deliberate practice to address each issue.

Software Architecturecareer transitioncommunication
0 likes · 8 min read
7 Common Pain Points When Software Engineers Become Architects (And How to Overcome Them)
Architectural Methodology
Architectural Methodology
Jun 2, 2026 · Industry Insights

Key Differences Between Software Architect and Senior Software Engineer Interviews

The article compares software architect and senior software engineer interviews, highlighting distinct mindsets, responsibilities, design scope, non‑functional focus, leadership expectations, typical questions, and evaluation artifacts, and explains why transitioning requires deliberate mindset shift rather than just experience accumulation.

Software Architectureinterview preparationrole comparison
0 likes · 7 min read
Key Differences Between Software Architect and Senior Software Engineer Interviews
IT Learning Made Simple
IT Learning Made Simple
Jun 2, 2026 · R&D Management

What Exactly Does a Software Architect Do? The Role That Involves More PPTs Than Coding

The article demystifies the software architect role by outlining core duties such as system design, technology selection, solving technical challenges, cross‑team coordination, a typical daily schedule, and how it differs from senior developers, while emphasizing that architects are not omnipotent but facilitators.

Software ArchitectureSystem Designrole comparison
0 likes · 8 min read
What Exactly Does a Software Architect Do? The Role That Involves More PPTs Than Coding
Architectural Methodology
Architectural Methodology
Jun 2, 2026 · R&D Management

Key Differences Between Architects and Senior Software Engineers

The article contrasts architects and senior software engineers, showing that developers focus on implementing specific features and optimizing code within a single module, while architects address system‑wide trade‑offs, future evolution, standards, and cross‑team coordination, highlighting distinct mindsets, responsibilities, decision costs, and communication skills essential for career growth.

Software Architecturecareer-developmentrole comparison
0 likes · 8 min read
Key Differences Between Architects and Senior Software Engineers
ZhiKe AI
ZhiKe AI
Jun 1, 2026 · Backend Development

Balancing Software Architecture Choices in Real Projects

The article explains that software architecture is fundamentally about trade‑offs, categorises major architecture families such as DDD, Clean/Hexagonal/Onion, Microservices vs SOA, CQRS/Event Sourcing, MVC, PACELC, BASE, FLP, Repository and 12‑Factor principles, and shows how each addresses specific constraints to help engineers pick the most suitable design for their context.

CAPClean ArchitectureDesign Patterns
0 likes · 12 min read
Balancing Software Architecture Choices in Real Projects
ZhiKe AI
ZhiKe AI
May 31, 2026 · Fundamentals

Do You Really Understand SOLID Design Principles?

This article expands the SOLID principles into a three‑layer framework—class, pattern, and component levels—clarifying common misinterpretations, presenting correct definitions with concrete examples, and showing how GRASP and design patterns operationalize these principles for stable, low‑coupling software.

Design PatternsDesign PrinciplesGRASP
0 likes · 14 min read
Do You Really Understand SOLID Design Principles?
ZhiKe AI
ZhiKe AI
May 31, 2026 · Fundamentals

Why Knowing 100 Coding Principles Still Won’t Make You Write Good Code: The 4 Misunderstood Rules

The article explains that developers often memorize dozens of rules such as DRY, KISS, YAGNI, SOLID, and CAP, yet still produce poor code because they misunderstand the original intent of these principles, illustrating the pitfalls with concrete examples, classic laws like Brooks' Law, and how mis‑interpretations cascade through design, architecture, and measurement practices.

CAP theoremDRYKISS
0 likes · 17 min read
Why Knowing 100 Coding Principles Still Won’t Make You Write Good Code: The 4 Misunderstood Rules
AI2ML AI to Machine Learning
AI2ML AI to Machine Learning
May 30, 2026 · Artificial Intelligence

Decoding the Harness Stack: Balancing Human Effort and AI Intelligence

The article analyzes Harness, a 2026 proposal that extends traditional agents with a seven‑layer architecture to fully emulate human experience, discusses rapid upgrades from prompts to skills, outlines development‑stack challenges, and presents six engineering principles for building reliable AI agents.

AGIAI AgentsHarness framework
0 likes · 9 min read
Decoding the Harness Stack: Balancing Human Effort and AI Intelligence
Java Tech Enthusiast
Java Tech Enthusiast
May 28, 2026 · R&D Management

Why Tech‑Obsessed Engineers Hit a Career Ceiling

The article argues that engineers who prioritize flashy technologies over business value quickly hit a career ceiling, illustrating the danger with over‑engineered micro‑service splits, costly AI projects, and loss of judgment, then offers practical habits and advice to align technology with real business outcomes.

Software Architecturebusiness alignmentcareer-development
0 likes · 8 min read
Why Tech‑Obsessed Engineers Hit a Career Ceiling
Architecture Breakthrough
Architecture Breakthrough
May 28, 2026 · R&D Management

Avoiding the ‘Air‑Castle’ Mindset: How Architects Combine Macro Vision and Micro Detail

The author reflects on a recent technical design presentation, analyzes strengths and gaps in the architecture process, and argues that only a top‑down macro view paired with bottom‑up micro‑level detail can prevent architects from drifting into vague, non‑actionable designs.

Design ProcessSoftware Architecturedetail design
0 likes · 5 min read
Avoiding the ‘Air‑Castle’ Mindset: How Architects Combine Macro Vision and Micro Detail
Su San Talks Tech
Su San Talks Tech
May 27, 2026 · Artificial Intelligence

Next AI Draw.io: AI‑Powered Diagramming 10× Faster Than Visio

The article introduces Next AI Draw.io, an AI‑enhanced web app that integrates with Claude Code to generate architecture, sequence, use‑case, activity, and mind‑map diagrams via natural‑language prompts, offering a workflow claimed to be ten times faster than traditional Visio drawing.

AI diagrammingClaude CodeMCP
0 likes · 5 min read
Next AI Draw.io: AI‑Powered Diagramming 10× Faster Than Visio
LuTiao Programming
LuTiao Programming
May 26, 2026 · Industry Insights

When AI Agents Stop Chatting and Start Running Your Workflows

A brief experiment shows that an AI agent can execute an entire refund workflow—from querying the order to notifying finance—without any user clicks, illustrating a shift from traditional UI‑driven software to AI‑driven workflow automation that could reshape enterprise systems.

AI AgentsAI industryEnterprise Software
0 likes · 7 min read
When AI Agents Stop Chatting and Start Running Your Workflows
TechVision Expert Circle
TechVision Expert Circle
May 26, 2026 · Industry Insights

Why Your System Isn’t Truly Yours: The Harsh Reality CTOs Must Face

The article reveals that most so‑called “self‑built” enterprise systems are merely assemblies of third‑party components—databases, cloud services, SaaS tools—and explains how license changes, API disruptions, and vendor lock‑in can erode a CTO’s control, then outlines practical steps for regaining architectural decision‑making authority by 2026.

AI GatewayCTODependency Management
0 likes · 13 min read
Why Your System Isn’t Truly Yours: The Harsh Reality CTOs Must Face