BestHub
Sign in
Tagged articles
401 articles
Page 1 of 5
AI Engineer Programming
AI Engineer Programming
Apr 29, 2026 · Fundamentals

Balancing Core Stability and Extensibility: Design and Implementation of pi Agent’s Extension System

The article explains how the pi agent’s extension system resolves the tension between core stability and capability extensibility by using inversion of control, dependency injection, adapter and event‑driven patterns, two‑phase initialization, and concrete Python implementations, while comparing it with other plugin architectures.

AI AgentEvent-drivenPython
0 likes · 26 min read
Balancing Core Stability and Extensibility: Design and Implementation of pi Agent’s Extension System
Architecture Musings
Architecture Musings
Apr 17, 2026 · Artificial Intelligence

Building AI‑Native Design Docs with Architecture as Code

The article explains why traditional diagram‑as‑code approaches fall short for AI agents, introduces Architecture as Code as a structured, version‑controlled alternative, discusses the role of interface contracts and narrative documentation, and outlines the need for deterministic context engineering to make design documents truly live for both humans and machines.

AI AgentsArchitecture as CodeContext Engineering
0 likes · 22 min read
Building AI‑Native Design Docs with Architecture as Code
Yunqi AI+
Yunqi AI+
Apr 11, 2026 · Fundamentals

Two Principles to Make AI‑Generated Code Easy to Maintain

The article explains how the Composed Method Pattern (CMP) and the Single Level of Abstraction Principle (SLAP) can keep AI‑generated code readable, maintainable, and team‑friendly by structuring entry methods as narratives and ensuring each method stays at a single abstraction level.

AI code generationCMPSLAP
0 likes · 16 min read
Two Principles to Make AI‑Generated Code Easy to Maintain
Architecture Musings
Architecture Musings
Apr 4, 2026 · Industry Insights

Exploring the Harness Architecture Concept: A First Look

This article examines the emerging "Harness Architecture" idea, arguing that constraints should be applied before AI code generation by leveraging stepwise refinement, modular contracts, and living design documents to improve precision, reduce token usage, and prevent architectural drift in large software projects.

AI EngineeringSpec‑Driven DevelopmentStepwise Refinement
0 likes · 8 min read
Exploring the Harness Architecture Concept: A First Look
AI Waka
AI Waka
Mar 25, 2026 · Artificial Intelligence

Why Persistent Specs Matter: Building Reliable AI Agents with an Artifact Layer

The article explains how an artifact layer—comprising specs, guidance files, skills, tests, and logs—preserves intent across AI agent sessions, enabling reliable, secure, and maintainable agent‑driven software development through spec‑first practices, bounded loops, and robust verification stacks.

AI AgentsSpec‑Driven Developmentagent engineering
0 likes · 16 min read
Why Persistent Specs Matter: Building Reliable AI Agents with an Artifact Layer
Selected Java Interview Questions
Selected Java Interview Questions
Mar 10, 2026 · Backend Development

Why Over‑Encapsulation Breaks Your Code and How to Fix It

The article explains how excessive, fake, or chaotic encapsulation creates hidden risks, reduces maintainability, and hampers extensibility, then provides concrete refactoring examples and practical principles to achieve clean, purposeful encapsulation in backend code.

Encapsulationbest practicescode maintainability
0 likes · 11 min read
Why Over‑Encapsulation Breaks Your Code and How to Fix It
IT Services Circle
IT Services Circle
Mar 4, 2026 · Fundamentals

Why utils.py Turns Into a Code Dump and 3 Better Alternatives

A bloated utils.py quickly becomes a maintenance nightmare because it mixes unrelated logic, hides business rules, and creates tight coupling, but by reorganizing functions into domain‑specific modules, class methods, or tiny generic utility packages you can restore clarity, testability, and scalability.

code organizationrefactoringsoftware design
0 likes · 11 min read
Why utils.py Turns Into a Code Dump and 3 Better Alternatives
Code Wrench
Code Wrench
Feb 20, 2026 · Fundamentals

Why Go and Rust Reject Inheritance: Embracing Composition Over Class Hierarchies

Developers transitioning from Java or C# to Go or Rust often miss class inheritance, but both languages deliberately avoid it; this article explains the pitfalls of inheritance, the benefits of composition, interfaces, and traits, and offers practical guidance for designing maintainable, concurrent systems without inheritance.

Traitssoftware design
0 likes · 10 min read
Why Go and Rust Reject Inheritance: Embracing Composition Over Class Hierarchies
SpringMeng
SpringMeng
Jan 29, 2026 · Fundamentals

Stop Over‑Encapsulating: How Bad Encapsulation Leads to Hidden Bugs

The article analyzes three harmful forms of improper encapsulation—over‑encapsulation, fake encapsulation, and chaotic encapsulation—illustrates each with Java code examples, explains the resulting development inefficiencies, extensibility issues, and debugging difficulties, and offers concrete principles to avoid these pitfalls.

EncapsulationJavacode quality
0 likes · 12 min read
Stop Over‑Encapsulating: How Bad Encapsulation Leads to Hidden Bugs
java1234
java1234
Jan 29, 2026 · Fundamentals

When Over‑Encapsulation Breaks Your Code: Real‑World Pitfalls and Fixes

The article analyzes three common forms of bad encapsulation in Java—over‑encapsulation, false encapsulation, and chaotic encapsulation—illustrates their hidden risks with concrete code examples, and offers practical principles to restore clear responsibilities, minimal interfaces, and flexible design.

EncapsulationJavaObject-Oriented
0 likes · 13 min read
When Over‑Encapsulation Breaks Your Code: Real‑World Pitfalls and Fixes
macrozheng
macrozheng
Jan 4, 2026 · Fundamentals

Master KISS, DRY, and SOLID: Practical Tips and Real‑World Code Examples

This article explains the core software design principles KISS, DRY, and SOLID, shows why they matter for readability and maintainability, provides concrete Java examples and step‑by‑step guidelines, and lists actionable rules developers can follow to write cleaner, more reusable code.

DRYKISSSOLID
0 likes · 19 min read
Master KISS, DRY, and SOLID: Practical Tips and Real‑World Code Examples
Tencent Cloud Developer
Tencent Cloud Developer
Nov 5, 2025 · Fundamentals

What Is Architecture? From 4+1 to C4 and Enterprise EA Explained

This article demystifies the concept of architecture by tracing its origins, explaining the 4+1 and C4 modeling approaches, introducing TOGAF‑4A, and clarifying the role of enterprise architecture in aligning people, processes, technology, and data to manage complexity across large organizations.

C4 ModelTOGAFarchitecture
0 likes · 12 min read
What Is Architecture? From 4+1 to C4 and Enterprise EA Explained
Tech Minimalism
Tech Minimalism
Nov 2, 2025 · Artificial Intelligence

Claude Code: How a Minimalist Design Turns an AI Tool into a True Programming Partner

Claude Code redefines AI programming assistants by abandoning complex multi‑agent architectures in favor of a single‑loop, single‑file design, leveraging Unix‑style simplicity, LLM‑based search, and sophisticated context engineering to act as a collaborative partner rather than a mere code‑completion tool.

AI programming assistantClaude CodeContext Engineering
0 likes · 12 min read
Claude Code: How a Minimalist Design Turns an AI Tool into a True Programming Partner
Liangxu Linux
Liangxu Linux
Oct 12, 2025 · Fundamentals

Mastering Strong and Weak Functions in C for Flexible Embedded Design

This article explains the concept of strong and weak functions in C, shows how to declare them with GCC and other compilers, outlines the linker selection rules, and demonstrates practical uses such as library overrides, interrupt handlers, callbacks, test stubs, plugin systems, and related pitfalls.

CLinkerembedded
0 likes · 9 min read
Mastering Strong and Weak Functions in C for Flexible Embedded Design
21CTO
21CTO
Sep 25, 2025 · Fundamentals

Master Python Coding Standards: 50 Essential Best Practices for Clean, Maintainable Code

This comprehensive guide presents 50 practical Python coding best‑practice rules covering naming, function design, object‑oriented principles, exception handling, code style, and project structure, showing how to write self‑explanatory, reusable, and robust code that stands the test of time and team collaboration.

Pythonclean codecoding standards
0 likes · 25 min read
Master Python Coding Standards: 50 Essential Best Practices for Clean, Maintainable Code
Tencent Cloud Developer
Tencent Cloud Developer
Sep 25, 2025 · Fundamentals

Unlock the Secrets of Object‑Oriented Analysis & Design for Better Software

This comprehensive guide explores the evolution of object‑oriented programming, clarifies its core concepts, and walks readers through use‑case modeling, static and dynamic modeling, responsibility‑driven design patterns, and advanced modeling techniques, providing a complete knowledge framework for software engineers and architects.

AnalysisDDDObject-Oriented
0 likes · 44 min read
Unlock the Secrets of Object‑Oriented Analysis & Design for Better Software
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 17, 2025 · Fundamentals

What Is Enterprise Application Architecture and How to Design It?

This article explains the definition of application architecture, distinguishes enterprise‑level and system‑level designs, outlines its core components—application services, structure, and interaction—and illustrates layered architectures and service interactions with diagrams, helping readers understand how to translate business architecture into concrete IT solutions.

System Designapplication architectureenterprise architecture
0 likes · 3 min read
What Is Enterprise Application Architecture and How to Design It?
21CTO
21CTO
Sep 13, 2025 · Fundamentals

Why Linus Torvalds Calls Certain Code “Garbage” and What It Means for Cognitive Load

Linus Torvalds harshly criticized a Meta engineer's pull request as garbage, using the incident to illustrate how unnecessary abstractions increase cognitive load, why code should be clear and self‑contained, and how modern tools like IDEs and LLMs change the cost of refactoring.

Linus TorvaldsPR reviewSoftware Engineering
0 likes · 7 min read
Why Linus Torvalds Calls Certain Code “Garbage” and What It Means for Cognitive Load
Java Web Project
Java Web Project
Sep 1, 2025 · Information Security

Why the Word “User” Is Killing Your Software Security and Design

The article argues that the vague term “user” misleads software design, illustrates the problem with airline reservation, Unix, and SaaS examples, shows how it creates security flaws like the Confused Deputy issue, and urges precise terminology early in projects to avoid costly rework.

SaaSSecurityTerminology
0 likes · 8 min read
Why the Word “User” Is Killing Your Software Security and Design
DaTaobao Tech
DaTaobao Tech
Aug 27, 2025 · Fundamentals

What Defines Good Code? Multi‑Dimensional Standards, Bad Smells, and Design Patterns Explained

This article explores what makes code truly good by examining functional, stability, user experience, efficiency, and cost dimensions, presenting the "Gold Code" evaluation criteria, discussing design principles, common code smells, practical examples, and how design patterns and layering affect readability and maintainability.

Code reviewcode qualitygood code
0 likes · 15 min read
What Defines Good Code? Multi‑Dimensional Standards, Bad Smells, and Design Patterns Explained
Liangxu Linux
Liangxu Linux
Aug 3, 2025 · Information Security

Why Calling Everyone a “User” Undermines Security and Design

The article explains how the vague term “user” leads to flawed requirements, security vulnerabilities such as the Confused Deputy problem, and costly redesigns, urging developers to adopt precise terminology like “traveler”, “agent”, or “member” early in a project.

Terminologyaccess controlsoftware design
0 likes · 7 min read
Why Calling Everyone a “User” Undermines Security and Design
MoonWebTeam
MoonWebTeam
Jul 24, 2025 · Fundamentals

Mastering the Open-Closed Principle: Benefits, Pitfalls, and Real-World Examples

This article explores the Open‑Closed Principle (OCP) in depth, covering its definition, evolution, practical applications, common misconceptions, code comparisons, and best‑practice guidelines to help developers balance extensibility with simplicity in modern software design.

Open/Closed PrincipleSOLIDTypeScript
0 likes · 19 min read
Mastering the Open-Closed Principle: Benefits, Pitfalls, and Real-World Examples
Code Mala Tang
Code Mala Tang
Jul 17, 2025 · Fundamentals

Why Object‑Oriented Programming Transforms Your Python Data Projects

Object‑oriented programming, though often overlooked in data‑centric Python scripts, becomes essential for managing complexity, improving readability, and enabling collaboration, as this guide demonstrates eight core OOP concepts—classes, encapsulation, inheritance, polymorphism, composition, class/staticmethods, magic methods, and abstract base classes—through clear examples.

OOPobject‑oriented programmingsoftware design
0 likes · 10 min read
Why Object‑Oriented Programming Transforms Your Python Data Projects
Didi Tech
Didi Tech
Jul 10, 2025 · Backend Development

Why Unit Testing Matters: Go Basics, Mocking, and Table‑Driven Tests

This article explains why unit testing is essential for code quality, API design, and documentation, then walks through Go's built‑in testing conventions, common *testing.T methods, table‑driven test patterns, mocking with gomonkey, and best practices for writing maintainable tests.

GoMockingsoftware design
0 likes · 27 min read
Why Unit Testing Matters: Go Basics, Mocking, and Table‑Driven Tests
macrozheng
macrozheng
Jun 19, 2025 · Fundamentals

Master PlantUML: Quick Guide to Creating Sequence Diagrams

This tutorial introduces PlantUML, explains its core features, shows how to install plugins for popular IDEs, and provides detailed syntax examples for participants, messages, lifelines, activation bars, groups, notes, and colors, culminating in a complete login flow diagram.

Code‑Based ModelingDiagrammingPlantUML
0 likes · 15 min read
Master PlantUML: Quick Guide to Creating Sequence Diagrams
Programmer DD
Programmer DD
Jun 16, 2025 · Backend Development

Why Self-Contained Systems Might Replace Microservices: Key Differences Explained

This article introduces Self-Contained Systems (SCS) as an alternative to microservices, outlines SCS core characteristics, compares both approaches across granularity, communication, UI handling and integration, and concludes with practical insights for large‑scale, multi‑team projects.

Backendarchitectureself-contained systems
0 likes · 8 min read
Why Self-Contained Systems Might Replace Microservices: Key Differences Explained
Continuous Delivery 2.0
Continuous Delivery 2.0
Jun 12, 2025 · Backend Development

Why Over‑Engineering and Bad Code Kill Your Project—and How to Fix It

This article reveals how common bad coding practices such as over‑engineering, hidden business logic in utility classes, deep inheritance trees, excessive DTO layers, unnecessary interfaces, and contract‑less microservices degrade team efficiency and project quality, and offers concrete, principle‑driven remedies.

Anti-PatternsBackend DevelopmentJava
0 likes · 8 min read
Why Over‑Engineering and Bad Code Kill Your Project—and How to Fix It
MoonWebTeam
MoonWebTeam
May 30, 2025 · Fundamentals

Why Layered Architecture Is the Key to Scalable Web Applications

This article explains the evolution and benefits of layered software architecture—from early two‑layer designs to MVC, DDD, Clean Architecture, and the Monet framework—highlighting how clear responsibilities, adaptability, and proper dependency direction improve maintainability, scalability, and team collaboration.

BackendClean ArchitectureDDD
0 likes · 18 min read
Why Layered Architecture Is the Key to Scalable Web Applications
MoonWebTeam
MoonWebTeam
May 24, 2025 · Frontend Development

How Clean Architecture and Vue 3 Composition API Simplify Complex Frontend Projects

This article examines the growing complexity of a points‑mall front‑end, identifies architectural and code‑organization pain points, and demonstrates how applying Clean Architecture together with Vue 3's Composition API can decouple business logic from UI, improve maintainability, and streamline development.

Clean ArchitectureComposition APIsoftware design
0 likes · 22 min read
How Clean Architecture and Vue 3 Composition API Simplify Complex Frontend Projects
macrozheng
macrozheng
Apr 9, 2025 · Fundamentals

Why Clean Code Matters: Practical Tips for Naming, Classes, Functions & Testing

This article explains why clean code is essential for productivity and team collaboration, outlines concrete guidelines for meaningful naming, single‑responsibility classes, concise functions, and effective testing, and shows how tools and refactoring can help maintain high code quality.

best practicesclean codenaming conventions
0 likes · 14 min read
Why Clean Code Matters: Practical Tips for Naming, Classes, Functions & Testing
Java Captain
Java Captain
Apr 7, 2025 · Fundamentals

Effective Object Naming: Avoiding “-er”/“-or” Suffixes, God Classes, and Building Intelligent Domain Objects

This article explains why thoughtful object naming—avoiding generic “er”/“or” suffixes and vague Service/Helper classes—improves code readability, maintainability, and AI‑assisted development, and demonstrates better designs with concrete C# examples that model real‑world business roles and adaptive behavior.

AI-assisted programmingSoftware Architectureclean code
0 likes · 12 min read
Effective Object Naming: Avoiding “-er”/“-or” Suffixes, God Classes, and Building Intelligent Domain Objects
Selected Java Interview Questions
Selected Java Interview Questions
Apr 3, 2025 · Fundamentals

How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing

This article explains why clean code is essential for team development and provides practical guidelines on naming, class design, function composition, and testing—including SOLID principles, meaningful identifiers, single‑responsibility classes, short functions, and test‑driven development—to improve readability, extensibility, and overall software quality.

clean codenaming conventionsrefactoring
0 likes · 19 min read
How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing
Architecture Breakthrough
Architecture Breakthrough
Mar 31, 2025 · Fundamentals

Why Mastering Abstraction Is the Real Skill Behind Great Software Design

The article explains that while encapsulation, inheritance, and polymorphism are often highlighted, true software craftsmanship hinges on the ability to abstract—identifying essential features, discarding irrelevant details, and modeling problem domains through steps like analysis, concept extraction, and system design, supported by principles such as low coupling, high cohesion, sufficiency, and completeness.

CohesionCouplingDomain-Driven Design
0 likes · 10 min read
Why Mastering Abstraction Is the Real Skill Behind Great Software Design
Eric Tech Circle
Eric Tech Circle
Jan 14, 2025 · Backend Development

DDD vs MVC: Practical Trade‑offs, Pitfalls, and When to Keep It Simple

This article compares Domain‑Driven Design and MVC, outlines the architectural changes such as dependency inversion and layer separation, examines common drawbacks in real projects, and offers concrete guidance on when to adopt DDD, blend it with MVC, or stick to a lightweight CRUD‑centric approach.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 9 min read
DDD vs MVC: Practical Trade‑offs, Pitfalls, and When to Keep It Simple
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 10, 2025 · Fundamentals

How to Design an SDK Business Model Diagram: A Step‑by‑Step Guide

This article explains how to build a business model diagram for an SDK from a design perspective, covering the definition of business model diagrams, their purpose, expression methods, layered architecture, derivation principles, a six‑step modeling process, and evaluation criteria to ensure clarity, correctness, and extensibility.

Business ModelModelingSDK
0 likes · 21 min read
How to Design an SDK Business Model Diagram: A Step‑by‑Step Guide
IT Architects Alliance
IT Architects Alliance
Dec 30, 2024 · Fundamentals

Building Scalable Modular System Architecture: Concepts, Steps, and Best Practices

The article explains why a scalable modular system architecture is essential, outlines its core concepts, detailed implementation steps, design principles, and real‑world case studies, and highlights technologies such as micro‑services, containers, and API gateways that enhance extensibility and maintainability.

System Integrationmodular architecturesoftware design
0 likes · 16 min read
Building Scalable Modular System Architecture: Concepts, Steps, and Best Practices
IT Architects Alliance
IT Architects Alliance
Dec 23, 2024 · Industry Insights

What Core Skills Must Modern IT Architects Master to Thrive?

This comprehensive guide outlines the essential technical, business, and leadership competencies—including programming, multi‑technology mastery, architectural principles, forward‑looking tech awareness, business understanding, and team management—that IT architects need to succeed in today’s fast‑evolving digital landscape.

Core SkillsIT ArchitectureLeadership
0 likes · 26 min read
What Core Skills Must Modern IT Architects Master to Thrive?
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.

AISoftware Engineeringagile
0 likes · 9 min read
Why AI Isn’t a Silver Bullet: Core Software Design Principles Revealed
Top Architect
Top Architect
Dec 1, 2024 · Fundamentals

Fundamentals of Software Design Documentation and UML Modeling

This article introduces the basics of software design documentation, explaining how software modeling and UML diagrams such as class, sequence, component, deployment, use case, state, and activity charts are used to capture domain problems and system architecture throughout requirement analysis, high‑level design, and detailed design phases.

DocumentationSoftware ModelingUML
0 likes · 16 min read
Fundamentals of Software Design Documentation and UML Modeling
Tencent Cloud Developer
Tencent Cloud Developer
Nov 28, 2024 · Backend Development

Contract-Based Design and Communication Challenges in Software Development

The article highlights how fragmented, undocumented cross‑team communication creates fragile software, then advocates adopting contract‑based design—preconditions, postconditions, invariants—and AI‑assisted tooling to formalize API contracts throughout the development lifecycle, aligning teams, reducing errors, and improving system reliability.

OpenAPIProtobufcommunication
0 likes · 18 min read
Contract-Based Design and Communication Challenges in Software Development
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 15, 2024 · R&D Management

Why Technical Architects Matter: System Thinking and Collaboration Models Explained

This article explores the essential role of technical architects, detailing their responsibilities, the challenges of traditional waterfall collaboration, and introducing a triangular collaboration model and a structured architecture design thinking framework to foster system thinking, proactive decision‑making, and effective team leadership.

Collaboration ModelR&D managementTechnical architecture
0 likes · 19 min read
Why Technical Architects Matter: System Thinking and Collaboration Models Explained
21CTO
21CTO
Nov 13, 2024 · Fundamentals

Why Clean Architecture Is the Key to Scalable, Resilient Software

Clean software architecture, built on principles like vertical and horizontal separation and proper module qualification, reduces complexity and technical debt, boosts scalability, flexibility, and reliability, and guides organizations in proactively managing architectural health through continuous assessment, AI-driven observability, and targeted team training.

Clean ArchitectureMicroservicesTechnical Debt
0 likes · 9 min read
Why Clean Architecture Is the Key to Scalable, Resilient Software
JD Tech
JD Tech
Nov 5, 2024 · Fundamentals

Simplifying Complexity: Principles and Practices for Cleaner Software Design

This article explores why simplicity is essential in software development, examines the distinction between essential and accidental complexity, presents real‑world case studies of product and code complexity, and offers practical guidelines such as KISS, single‑responsibility, API minimization, and automation to achieve more maintainable and understandable systems.

KISSapi-designcode simplicity
0 likes · 24 min read
Simplifying Complexity: Principles and Practices for Cleaner Software Design
JD Cloud Developers
JD Cloud Developers
Oct 29, 2024 · Fundamentals

Why Simplicity Wins: Turning Complex Code and Design into Clean Solutions

The article explores how software engineers can reduce both essential and accidental complexity by unifying terminology, eliminating side‑effects, applying the KISS principle, and adopting clear architectural and API designs, ultimately delivering more maintainable and understandable systems.

KISS principlearchitecturebest practices
0 likes · 23 min read
Why Simplicity Wins: Turning Complex Code and Design into Clean Solutions
DaTaobao Tech
DaTaobao Tech
Oct 21, 2024 · Fundamentals

The True Purpose of Classes and Functions: Beyond Reuse

The article argues that classes and functions serve as fundamental structural elements rather than mere tools for reuse, contending that excessive reuse can increase complexity while intentional redundancy simplifies maintenance, and advocating deep modules over shallow ones, illustrated by examples from Supercell, DingTalk, and a trivial shallow‑module code snippet.

DDDDRY principleSoftware Architecture
0 likes · 8 min read
The True Purpose of Classes and Functions: Beyond Reuse
Code Mala Tang
Code Mala Tang
Oct 3, 2024 · Fundamentals

Mastering the Interface Segregation Principle: Why Small Interfaces Boost Code Quality

Learn how the Interface Segregation Principle (ISP) of SOLID design encourages splitting large interfaces into focused, minimal ones, reducing unnecessary method implementations, improving maintainability, and enhancing modularity across backend Java code, frontend React components, and state‑management modules, while also noting its trade‑offs.

JavaReactSOLID
0 likes · 16 min read
Mastering the Interface Segregation Principle: Why Small Interfaces Boost Code Quality
Test Development Learning Exchange
Test Development Learning Exchange
Sep 25, 2024 · Fundamentals

Duck Typing and Polymorphism in Python

This article explains duck typing and polymorphism in Python, two fundamental object-oriented programming concepts, with practical code examples demonstrating how objects can be treated based on their behavior rather than their type.

Code ExamplesPythonduck-typing
0 likes · 8 min read
Duck Typing and Polymorphism in Python
DevOps
DevOps
Sep 24, 2024 · Fundamentals

From Business Modeling to Use Case Diagrams: A Comprehensive Guide

This article explains how to move from business modeling to business and system use case diagrams, covering vision definition, business sequence diagrams, system use case creation, use case specifications, and concludes with a brief promotion for a DevOps certification course, offering practical guidance for software engineers.

Use Case Diagrambusiness modelingrequirements analysis
0 likes · 17 min read
From Business Modeling to Use Case Diagrams: A Comprehensive Guide
Architect
Architect
Sep 17, 2024 · Fundamentals

Why Design and Modeling Matter Before You Start Coding – A Practical Guide

The article examines modern software development challenges, explains why thorough design and modeling are essential before coding, and outlines three key practices—business modeling, business process analysis, and system modeling—along with class analysis techniques to improve collaboration, reduce rework, and build robust architectures.

ModelingSoftware Engineeringarchitecture
0 likes · 12 min read
Why Design and Modeling Matter Before You Start Coding – A Practical Guide
DevOps
DevOps
Sep 12, 2024 · Fundamentals

Advantages, Disadvantages, and Principles of Layered Architecture

This article examines the common benefits, drawbacks, and design principles of layered architecture across micro‑service, data‑warehouse, and protocol designs, illustrating each point with real‑world examples and offering practical guidance on when and how to apply layering effectively.

Data Warehousedesign principleslayered architecture
0 likes · 11 min read
Advantages, Disadvantages, and Principles of Layered Architecture
Tencent Cloud Developer
Tencent Cloud Developer
Sep 11, 2024 · Fundamentals

Advantages, Disadvantages, and Principles of Layered Architecture in Software Systems

Layered architecture offers abstract stability, functional reuse, cohesion, hidden complexity, and scalability, but can introduce extra complexity, performance overhead, and dependency risk, so designers should retain essential layers, enforce one‑way cross‑layer calls, depend only on lower layers, keep lower layers stable, and ensure each layer has a clear purpose.

DDDData WarehouseMicroservices
0 likes · 11 min read
Advantages, Disadvantages, and Principles of Layered Architecture in Software Systems
G7 EasyFlow Tech Circle
G7 EasyFlow Tech Circle
Sep 9, 2024 · Product Management

What Can Logistics Software Learn from Oracle EBS and OFSA Design?

This article examines how the flexible, metadata‑driven architecture and configurable features of Oracle E‑Business Suite and OFSA can inspire more adaptable, modular, and user‑centric logistics software, covering design principles, extensibility, integration, and data‑model strategies.

LogisticsOFSAOracle EBS
0 likes · 25 min read
What Can Logistics Software Learn from Oracle EBS and OFSA Design?
DevOps
DevOps
Sep 4, 2024 · Fundamentals

Concept‑Driven Software Design: From Daniel Jackson’s “Concept” to Business‑Service‑Driven Development with AI Assistance

The article analyses Daniel Jackson’s concept‑driven software design presented at the 2024 Global Software R&D Conference, relates it to domain‑driven design and business services, and demonstrates how AI‑augmented prompts can generate Java domain models and a Spring‑Boot RESTful API for order submission.

AI-assisted developmentDomain-Driven Designbusiness services
0 likes · 17 min read
Concept‑Driven Software Design: From Daniel Jackson’s “Concept” to Business‑Service‑Driven Development with AI Assistance
DevOps
DevOps
Aug 12, 2024 · Fundamentals

The Importance of Design and Modeling in Software Development

This article explains why software engineers should perform design and modeling—such as business modeling, process analysis, and system modeling—before writing code, highlighting how these practices align development with business goals, improve collaboration, and reduce costly rework caused by changing requirements.

ModelingObject-OrientedSoftware Architecture
0 likes · 9 min read
The Importance of Design and Modeling in Software Development
Tencent Cloud Developer
Tencent Cloud Developer
Aug 7, 2024 · Fundamentals

Design and Modeling: Essential Practices for Effective Software Development

Before writing code, developers should perform systematic design and modeling—including business modeling, process analysis, and system modeling—followed by class analysis and state‑machine design, to align software with business goals, reduce changing requirements, improve quality, and keep teams motivated.

Software EngineeringSystem Architecturesoftware design
0 likes · 10 min read
Design and Modeling: Essential Practices for Effective Software Development
Top Architect
Top Architect
Jul 15, 2024 · Fundamentals

Clean Code Practices: Naming, Classes, Functions, and Testing

This article explains why maintaining clean, well‑structured code is essential for productivity and team collaboration, covering naming conventions, class design principles, function responsibilities, testing strategies, and tools like SonarLint, while providing concrete Java code examples for each concept.

clean codenaming conventionssoftware design
0 likes · 16 min read
Clean Code Practices: Naming, Classes, Functions, and Testing
macrozheng
macrozheng
Jun 29, 2024 · Fundamentals

Master Clean Code: Proven Naming Conventions Every Developer Should Follow

This article explains why clean, well‑named code is essential for productivity, outlines practical naming rules—such as avoiding ambiguity, preventing misleading names, making meaningful distinctions, and keeping identifiers searchable—and provides concrete Java examples and patterns to help developers write maintainable, testable software.

clean codecode readabilitynaming conventions
0 likes · 18 min read
Master Clean Code: Proven Naming Conventions Every Developer Should Follow
DevOps
DevOps
Jun 17, 2024 · Product Management

Understanding Software Requirement Changes and the Software Value Model

The article examines why software requirements frequently change, introduces a four‑layer software value model—from business value to UI aesthetics—and explains how this model guides product managers and engineers in handling requirement volatility, balancing flexibility, and maintaining architectural integrity.

Software Architecturebusiness valueproduct-management
0 likes · 8 min read
Understanding Software Requirement Changes and the Software Value Model
Go Programming World
Go Programming World
May 30, 2024 · Backend Development

Standardizing RESTful API Error Handling with Business Error Codes and an Error Package in Go

This article explains how to design a unified business error‑code system for RESTful APIs, demonstrates the structure and format of such codes, provides a Go implementation with structs, interfaces and formatting methods, and shows practical usage in a Gin web server including logging and notification strategies.

BackendError CodesError Handling
0 likes · 22 min read
Standardizing RESTful API Error Handling with Business Error Codes and an Error Package in Go
Ops Development & AI Practice
Ops Development & AI Practice
May 27, 2024 · Fundamentals

Why Structured Programming Alone Falls Short and How OOP & FP Fill the Gaps

The article examines the drawbacks of relying solely on structured programming—such as tight module coupling, poor change isolation, and rigidity—and shows how integrating object‑oriented and functional programming can improve modularity, flexibility, and maintainability in complex software systems.

Programming Paradigmsfunctional programmingobject‑oriented programming
0 likes · 5 min read
Why Structured Programming Alone Falls Short and How OOP & FP Fill the Gaps
Dangbei Technology Team
Dangbei Technology Team
May 27, 2024 · Backend Development

How COLA Architecture Transforms Complex Backend Systems

The COLA (Clean Object‑Oriented and Layered Architecture) framework replaces traditional monolithic MVC Service layers with a clear, multi‑layered structure—Adapter, Application, Domain, Infrastructure, and Client—enhancing code cohesion, reducing coupling, and improving maintainability, as illustrated through a detailed order‑creation example with refactored Java code.

COLA ArchitectureJavaMicroservices
0 likes · 11 min read
How COLA Architecture Transforms Complex Backend Systems
Architecture Breakthrough
Architecture Breakthrough
May 27, 2024 · Fundamentals

Mastering Problem Analysis: A Six‑Step Framework for Clear Requirements

This article presents a practical six‑step framework that guides teams from clarifying business goals and core concepts to objectively breaking down issues, restructuring existing designs, proposing solutions, and finalizing implementation plans, helping avoid wasted effort on ill‑defined problems.

object-oriented analysisproblem analysisrequirements engineering
0 likes · 8 min read
Mastering Problem Analysis: A Six‑Step Framework for Clear Requirements
Su San Talks Tech
Su San Talks Tech
May 27, 2024 · Fundamentals

Master PlantUML: From Quick Start to Advanced Sequence Diagram Techniques

This article introduces PlantUML, explains its core features, walks through quick installation and plugin setup, demonstrates basic and advanced sequence diagram syntax with code examples, and provides a complete login flow illustration, helping developers create clear, version‑controlled diagrams efficiently.

PlantUMLSequence DiagramTutorial
0 likes · 13 min read
Master PlantUML: From Quick Start to Advanced Sequence Diagram Techniques
21CTO
21CTO
May 19, 2024 · Fundamentals

Mastering Software Abstraction: How to Design Clear, Maintainable Systems

This article explores the power of abstraction in software design, explaining its hierarchical levels, the role of interfaces, and practical questions to ask when modeling real‑world problems, guiding developers to create more maintainable, scalable, and communicative systems.

InterfacesSOLIDabstraction
0 likes · 7 min read
Mastering Software Abstraction: How to Design Clear, Maintainable Systems
Java Architect Essentials
Java Architect Essentials
May 14, 2024 · Fundamentals

Master Clean Code: Naming, Classes, Functions, and Testing Made Simple

This article explains why clean code is essential for productivity and project health, and provides practical guidance on naming, class design, function design, and testing—including SOLID principles, parameter handling, exception use, and test‑driven development—to help developers write maintainable, high‑quality software.

SOLIDclean codenaming conventions
0 likes · 17 min read
Master Clean Code: Naming, Classes, Functions, and Testing Made Simple
Architecture Digest
Architecture Digest
May 9, 2024 · Fundamentals

Clean Code Practices: Naming, Classes, Functions, and Testing

This article explains why clean code matters for productivity and project health, and provides practical guidelines on naming, class design, function design, SOLID principles, testing strategies, and tooling to help developers write maintainable, readable software.

SOLIDclean codenaming conventions
0 likes · 13 min read
Clean Code Practices: Naming, Classes, Functions, and Testing
Top Architect
Top Architect
May 7, 2024 · Fundamentals

Clean Code Principles: Naming, Classes, Functions, and Testing Practices

This article explains why clean code is essential for productivity and project health, covering naming conventions, class design, SOLID principles, function design, parameter handling, testing strategies like TDD and the FIRST principles, and tools such as SonarLint to maintain code quality.

clean codenaming conventionsrefactoring
0 likes · 18 min read
Clean Code Principles: Naming, Classes, Functions, and Testing Practices
Sanyou's Java Diary
Sanyou's Java Diary
Apr 30, 2024 · Fundamentals

Mastering Architecture Diagrams: When, Why, and How to Build Clear System Blueprints

This comprehensive guide explains the purpose of architecture diagrams, the criteria for good diagrams, the optimal moments to create them, and detailed methods for drawing business, application, technical, code, and data architecture diagrams, complete with design principles, classification, and practical tips.

Technical architecturearchitecture diagramsbusiness architecture
0 likes · 21 min read
Mastering Architecture Diagrams: When, Why, and How to Build Clear System Blueprints
php Courses
php Courses
Apr 15, 2024 · Fundamentals

Understanding Abstraction in Object-Oriented PHP Programming

This article explains the core concept of abstraction in software engineering, illustrating how using interfaces and abstract methods in PHP can simplify code, improve maintainability, and reduce developer focus on low‑level details, demonstrated through concrete Shape examples for rectangles, circles, and triangles.

InheritanceInterfacesPHP
0 likes · 5 min read
Understanding Abstraction in Object-Oriented PHP Programming
macrozheng
macrozheng
Apr 9, 2024 · Fundamentals

Mastering UML: 7 Essential Diagrams for Every Software Design Phase

This guide explains the seven core UML diagrams—class, sequence, component, deployment, use‑case, state, and activity—detailing when and how to use each across requirement analysis, architecture design, and detailed design to produce clear, actionable software design documentation.

Class DiagramModelingUML
0 likes · 13 min read
Mastering UML: 7 Essential Diagrams for Every Software Design Phase
Java Architect Essentials
Java Architect Essentials
Mar 27, 2024 · Cloud Native

Rethinking Microservices: Why Google, Amazon and Others Are Moving Away from Traditional Microservice Architectures

In 2023, major tech companies such as Google and Amazon publicly questioned the benefits of traditional microservice architectures, presenting new "microservice 2.0" concepts, monolithic alternatives, and cost‑performance analyses that highlight a broader industry shift toward more pragmatic, cloud‑native design approaches.

Cost Optimizationarchitecturecloud-native
0 likes · 12 min read
Rethinking Microservices: Why Google, Amazon and Others Are Moving Away from Traditional Microservice Architectures
Java Backend Technology
Java Backend Technology
Mar 25, 2024 · Fundamentals

5 Powerful Alternatives to If‑Else for Cleaner, Maintainable Code

This article explains why traditional if‑else statements often lead to complex, hard‑to‑read code and presents five practical techniques—including removing unnecessary else blocks, using fast returns, guard clauses, dictionary lookups, and the strategy pattern—to refactor and eliminate if‑else structures for more robust software design.

Code RefactoringStrategy Patternguard-clauses
0 likes · 8 min read
5 Powerful Alternatives to If‑Else for Cleaner, Maintainable Code
Architect
Architect
Mar 22, 2024 · Fundamentals

Why Every Engineer Needs a Good Architecture Diagram: Purpose, Types, and How to Create One

This guide explains the purpose of architecture diagrams, defines what makes a diagram effective, outlines when to draw them, classifies the various diagram types (business, application, technical, code, data), and provides step‑by‑step design principles, visual guidelines, and real‑world examples to help engineers communicate complex systems clearly.

System Architecturearchitecture diagramsoftware design
0 likes · 25 min read
Why Every Engineer Needs a Good Architecture Diagram: Purpose, Types, and How to Create One
Tencent Cloud Developer
Tencent Cloud Developer
Mar 20, 2024 · Fundamentals

How to Draw Effective Architecture Diagrams: A Comprehensive Guide

This guide explains how to create clear, visually appealing architecture diagrams—covering purpose, audience, design principles, timing, classification, and step‑by‑step drawing techniques—so teams can communicate structure, workflows, and data effectively across business, product, application, technical, and code domains.

System ArchitectureUML diagramsarchitecture diagrams
0 likes · 20 min read
How to Draw Effective Architecture Diagrams: A Comprehensive Guide
Efficient Ops
Efficient Ops
Feb 27, 2024 · Artificial Intelligence

Can Large Language Models Truly Elevate Software Engineering? Insights and Roadmap

This article reviews the 2023 surge of large language models in software engineering, evaluates their current code generation, testing, and knowledge‑query capabilities, highlights persistent challenges in design and maintenance, and proposes concrete recommendations for advancing toward higher‑level intelligent development.

Code GenerationSoftware Engineeringdigital twins
0 likes · 21 min read
Can Large Language Models Truly Elevate Software Engineering? Insights and Roadmap
Architects Research Society
Architects Research Society
Feb 14, 2024 · Fundamentals

Overview of Modern Application Architecture Trends and Principles

The article outlines emerging forces such as cloud, mobile, social, and big data that drive modern application architecture, advocates moving beyond traditional three‑tier designs, and recommends adopting service‑oriented, microservice, event‑driven, and open‑standard approaches while considering paradigms, models, and organizational structures.

Event-drivenMicroservicesSOA
0 likes · 11 min read
Overview of Modern Application Architecture Trends and Principles
Top Architect
Top Architect
Jan 10, 2024 · Fundamentals

PlantUML Tutorial: Installation, Usage, Diagram Types, and Practical Example

This article introduces PlantUML, explains how to install its plugins for IDEs, demonstrates various diagram types such as activity, class, component, and sequence, and provides a practical code example for modeling authentication flows, making it a comprehensive guide for creating UML diagrams efficiently.

Code GenerationDiagramPlantUML
0 likes · 8 min read
PlantUML Tutorial: Installation, Usage, Diagram Types, and Practical Example
Liangxu Linux
Liangxu Linux
Dec 27, 2023 · Fundamentals

Why Callbacks Are Just Function Variables: A Simple C Example

This article explains that callbacks are essentially function variables, illustrating the concept with plain C code examples, comparing direct function calls to passing functions as parameters, and showing how this approach avoids massive if‑else chains while keeping the logic clear and reusable.

C programmingCallbacksfunction pointers
0 likes · 3 min read
Why Callbacks Are Just Function Variables: A Simple C Example
Cognitive Technology Team
Cognitive Technology Team
Dec 23, 2023 · Fundamentals

Tactical vs Strategic Programming: Understanding System Complexity and Design Principles

The article explains how tactical programming—prioritizing rapid feature delivery by piling code—creates system complexity through change amplification, cognitive load, and unknown unknowns, and advocates strategic programming that invests in design, reduces dependencies and ambiguity, and builds sustainable software architecture.

code qualitysoftware designstrategic programming
0 likes · 8 min read
Tactical vs Strategic Programming: Understanding System Complexity and Design Principles
DaTaobao Tech
DaTaobao Tech
Dec 13, 2023 · Backend Development

Understanding VSEF Architecture: Core Structure, Evolution, and Component Selection

The article explains VSEF’s three‑layer architecture—entry, kernel, and dependencies—detailing how evolutionary themes, component selection, and design patterns such as Template Method and Strategy enable a stable core while allowing flexible, domain‑specific extensions through both market and self‑built modules.

architecturecomponentssoftware design
0 likes · 16 min read
Understanding VSEF Architecture: Core Structure, Evolution, and Component Selection