BestHub
Sign in
Tagged articles
401 articles
Page 2 of 5
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 23, 2023 · Backend Development

Understanding DDD Layered Architecture and Its Role in Microservice Design

The article explains clean, hexagonal, and DDD layered architectures, detailing each layer’s responsibilities, principles, and evolution, and shows how DDD layering enhances microservice design, promotes strict separation, supports architectural evolution, and guides the transition from traditional three‑tier systems to modern domain‑driven microservices.

Clean ArchitectureDDDHexagonal Architecture
0 likes · 21 min read
Understanding DDD Layered Architecture and Its Role in Microservice Design
DevOps
DevOps
Nov 5, 2023 · Fundamentals

Software Design Principles and Architectural Best Practices

This article discusses essential software design principles such as SOLID, DRY, dependency inversion, composition over inheritance, error handling, and the importance of clear documentation, illustrating them with Go code examples and practical guidelines for building maintainable, adaptable systems.

SOLIDarchitecturebest practices
0 likes · 45 min read
Software Design Principles and Architectural Best Practices
Senior Brother's Insights
Senior Brother's Insights
Nov 2, 2023 · Backend Development

Master Go Interfaces: 14 Best Practices for Cleaner, More Maintainable Code

This article presents fourteen practical guidelines for designing Go interfaces, covering small interfaces, avoiding type switches, using interfaces for mocking, composition, proper abstraction levels, avoiding empty interfaces, cautious type assertions, full implementation, behavior declaration, and other pitfalls to write robust backend code.

Interfacessoftware design
0 likes · 5 min read
Master Go Interfaces: 14 Best Practices for Cleaner, More Maintainable Code
MaGe Linux Operations
MaGe Linux Operations
Oct 29, 2023 · Backend Development

Microservices vs Event-Driven Architecture: Key Differences Explained

Explore the essential distinctions between microservices and event‑driven architecture, covering service granularity, data handling, bounded contexts, and practical use‑case scenarios, to help architects and developers choose the right approach for scalable, responsive software systems.

Event-Driven ArchitectureMicroservicesSystem Architecture
0 likes · 8 min read
Microservices vs Event-Driven Architecture: Key Differences Explained
Java Backend Technology
Java Backend Technology
Oct 20, 2023 · Fundamentals

5 Better Alternatives to If‑Else for Cleaner, More Maintainable Code

This article explores five practical techniques to replace traditional if‑else statements—removing unnecessary else blocks, using value assignment, applying guard clauses, leveraging dictionaries, and employing strategy patterns—demonstrating how each approach improves readability, maintainability, and adheres to solid design principles.

Code RefactoringStrategy Patternguard-clause
0 likes · 8 min read
5 Better Alternatives to If‑Else for Cleaner, More Maintainable Code
Tencent Cloud Developer
Tencent Cloud Developer
Oct 11, 2023 · Frontend Development

Clean Architecture in Front-End Development: Principles, Practices, and Comparative Analysis

The article explains why solid software architecture matters, introduces Robert C. Martin’s Clean Architecture and its framework‑, UI‑, database‑, and service‑independent principles, compares it with Hexagonal and DDD layered styles, details strategic and tactical phases for front‑end MVVM projects, provides layered code samples, and weighs its benefits against the initial overhead, urging teams to choose the approach that fits their project’s complexity and lifespan.

Architecture PatternsClean ArchitectureDomain-Driven Design
0 likes · 21 min read
Clean Architecture in Front-End Development: Principles, Practices, and Comparative Analysis
Architect
Architect
Oct 5, 2023 · Fundamentals

Mastering Clean Code: Naming, Classes, Functions, and Tests Explained

This article explains why clean code matters, demonstrates how meaningful naming, single‑responsibility classes, well‑structured functions, and disciplined testing (TDD and the FIRST principles) improve readability, maintainability, and productivity, using concrete Java examples, refactorings, and step‑by‑step guidelines.

TDDclean codenaming conventions
0 likes · 17 min read
Mastering Clean Code: Naming, Classes, Functions, and Tests Explained
Java High-Performance Architecture
Java High-Performance Architecture
Oct 1, 2023 · Fundamentals

Why Clean Code Matters: Practical Tips to Write Maintainable Java

This article summarizes key lessons from 'Clean Code', explaining why maintaining clean, readable Java code boosts productivity, reduces bugs and costs, and detailing practical guidelines for naming, class design, functions, testing, and refactoring to help developers write high‑quality, maintainable software.

clean codecoding standardsrefactoring
0 likes · 15 min read
Why Clean Code Matters: Practical Tips to Write Maintainable Java
Architecture Digest
Architecture Digest
Sep 28, 2023 · Fundamentals

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

This article explains why clean code is essential for productivity and team collaboration, and provides practical guidelines on naming, class design, function design, and testing—including principles like single responsibility, SOLID, meaningful naming, minimal parameters, and test‑driven development—to help developers produce readable, extensible, and reliable software.

SOLIDclean codenaming conventions
0 likes · 14 min read
How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing
Java Architect Essentials
Java Architect Essentials
Sep 27, 2023 · Fundamentals

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

This article explains why clean code is essential for productivity and business health, and provides practical guidelines on naming, class design, function design, and testing—including code examples, refactoring techniques, and quality‑checking tools—to help developers produce readable, maintainable, and extensible software.

TDDclean codecode quality
0 likes · 14 min read
How to Write Clean Code: Naming, Classes, Functions, and Testing Best Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 1, 2023 · Fundamentals

Mastering Software Analysis & Design: Logic, Methods, and Real‑World Cases

This article explains the logical framework of software analysis and design, outlines practical methods and principles, introduces essential UML tools, and demonstrates the concepts with two concrete case studies—a logging framework and a task‑scheduling framework—providing a complete guide for developers.

UMLdesign principleslogging framework
0 likes · 20 min read
Mastering Software Analysis & Design: Logic, Methods, and Real‑World Cases
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 24, 2023 · Fundamentals

Mastering Domain Modeling: A Practical Guide to Building Robust Business Models

This article explains how software engineers can systematically abstract real‑world problems into domain models, walk through four essential modeling steps, illustrate the process with multiple real‑world cases, and discuss advanced techniques such as event storming, four‑color modeling, and bounded‑context pen‑paper methods to create stable, extensible software designs.

DDDDomain ModelingEvent Storming
0 likes · 20 min read
Mastering Domain Modeling: A Practical Guide to Building Robust Business Models
MoonWebTeam
MoonWebTeam
Aug 23, 2023 · Frontend Development

Unlocking Flexibility: How Microkernel Architecture Powers Modern Front‑End Plugin Systems

This article explains the principles, advantages, and classifications of microkernel (plugin) architecture, demonstrates three common plugin patterns—pipeline, onion, and event‑driven—with real‑world examples such as VS Code, Gulp, and webpack, and shares practical implementation steps and best practices for applying microkernel design in front‑end projects.

Event-drivencode modularityfrontend development
0 likes · 32 min read
Unlocking Flexibility: How Microkernel Architecture Powers Modern Front‑End Plugin Systems
Goodme Frontend Team
Goodme Frontend Team
Jul 17, 2023 · Frontend Development

Mastering Clean Architecture for Frontend: A Practical Guide with React & TypeScript

This article explains clean architecture concepts—domain, use case, and application layers—and demonstrates how to apply them in a frontend React/TypeScript project, covering design principles, layer responsibilities, dependency rules, advantages, costs, and concrete code examples for a cookie‑shop example.

Clean ArchitectureDomain-Driven DesignHexagonal Architecture
0 likes · 40 min read
Mastering Clean Architecture for Frontend: A Practical Guide with React & TypeScript
Test Development Learning Exchange
Test Development Learning Exchange
Jul 7, 2023 · Fundamentals

Understanding the Command Pattern with Python Examples

The article introduces the Command design pattern, explains its key roles such as Command, ConcreteCommand, Receiver, Invoker, and Client, outlines its advantages, and provides multiple Python code examples demonstrating light control, undo operations, file handling, shopping cart management, and menu actions.

Command PatternDesign PatternsObject-Oriented
0 likes · 10 min read
Understanding the Command Pattern with Python Examples
Bilibili Tech
Bilibili Tech
Jul 7, 2023 · Backend Development

Applying DDD and Hexagonal Architecture to Build a Unified Danmaku Platform

The article explains how Bilibili’s senior engineer uses Domain‑Driven Design combined with hexagonal architecture to merge separate VOD and live‑stream Danmaku services into a unified platform, detailing sub‑domain decomposition, six‑sided ports, rich models, mapping logic, and the trade‑offs of improved modularity, maintainability, and reduced duplication versus added design and refactoring effort.

DDDDomain ModelingGo
0 likes · 21 min read
Applying DDD and Hexagonal Architecture to Build a Unified Danmaku Platform
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 6, 2023 · Fundamentals

Mastering Software Complexity: Design Principles and Real-World Patterns

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

Javaarchitecturecomplexity
0 likes · 19 min read
Mastering Software Complexity: Design Principles and Real-World Patterns
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 3, 2023 · Fundamentals

Mastering Code Refactoring: Practical Techniques and Real-World Examples

This article explains the definition, goals, and common techniques of code refactoring, illustrated with clear before‑and‑after Java examples such as method extraction, variable extraction, conditional simplification, and abstract‑class extraction, and concludes with a brief Q&A on best practices.

Abstract ClassMethod Extractionconditional refactoring
0 likes · 17 min read
Mastering Code Refactoring: Practical Techniques and Real-World Examples
JD Tech
JD Tech
Jun 29, 2023 · Backend Development

Deriving a DDD Application Architecture from a Three‑Layer Structure and Implementing It as a Maven Archetype

This article starts from a conventional three‑layer architecture, refines it into a domain‑driven design (DDD) application structure, demonstrates the evolution through five concrete steps, and shows how to package the final architecture as a reusable Maven Archetype with detailed installation and usage instructions.

ArchetypeDDDDomain-Driven Design
0 likes · 17 min read
Deriving a DDD Application Architecture from a Three‑Layer Structure and Implementing It as a Maven Archetype
dbaplus Community
dbaplus Community
May 31, 2023 · Fundamentals

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

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

DDDMicroservicesarchitecture
0 likes · 26 min read
Why Architecture Design Matters: Tackling System Complexity with Microservices & DDD
Open Source Linux
Open Source Linux
May 26, 2023 · Fundamentals

Top Free Diagramming Tools Every Engineer Should Know

This article introduces several free, easy‑to‑use diagramming tools—including Excalidraw, Zen Flowchart, Visual Paradigm Online, draw.io, Liuchengtu, and ProcessOn—highlighting their key features, collaboration capabilities, and where to access them.

Diagrammingfree toolsonline whiteboard
0 likes · 8 min read
Top Free Diagramming Tools Every Engineer Should Know
Top Architect
Top Architect
May 17, 2023 · Fundamentals

How to Draw Effective Architecture Diagrams

This article explains how to create clear and effective software architecture diagrams by defining architecture concepts, describing various diagram types such as business, application, technical and data architectures, introducing the 4+1 and C4 view models, and offering practical tips on audience targeting, visual elements, and consistency with code.

4+1 viewC4 ModelDiagram
0 likes · 9 min read
How to Draw Effective Architecture Diagrams
Alibaba Cloud Developer
Alibaba Cloud Developer
May 8, 2023 · Fundamentals

Transform Spaghetti Code into Clean Architecture with 3 Powerful Patterns

This article redefines what constitutes good code by using a star‑chart analogy, exposing typical spaghetti‑code pitfalls, and introducing three design patterns—Value Object, Side‑Effect‑Free Function, and Intention‑Revealing Interface—to help developers refactor and write maintainable software.

Value Objectcode qualityintention-revealing
0 likes · 13 min read
Transform Spaghetti Code into Clean Architecture with 3 Powerful Patterns
Java Backend Technology
Java Backend Technology
May 4, 2023 · Fundamentals

Master Java Class Naming: 10 Common Patterns for Clean, Professional Code

This article explores the most frequent Java class‑naming conventions—covering management, propagation, callbacks, monitoring, memory management, filtering, structural, design‑pattern, parsing, network, and other utility categories—providing clear examples for each to help developers write cleaner, more expressive code.

Javaclass namingcoding conventions
0 likes · 17 min read
Master Java Class Naming: 10 Common Patterns for Clean, Professional Code
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 11, 2023 · Fundamentals

Why Software Gets Complex and How to Measure & Tame It

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

Halsteadcode metricscyclomatic complexity
0 likes · 22 min read
Why Software Gets Complex and How to Measure & Tame It
Architects' Tech Alliance
Architects' Tech Alliance
Apr 2, 2023 · Fundamentals

General Software Architecture Overview and Implementation

This article presents a comprehensive overview of a flexible, layered software architecture—covering gateway, business, and foundation layers—explaining how to evolve from simple startup setups to adaptable structures that support HTTP/TCP handling, service design, component abstraction, and common technical components.

BackendBusiness Layergateway
0 likes · 12 min read
General Software Architecture Overview and Implementation
Architecture Breakthrough
Architecture Breakthrough
Mar 27, 2023 · R&D Management

How Extension Points Empower Scalable Platform Architecture

This article analyzes the concept of extension points, explains why traditional if‑else or naive strategy patterns break the Open‑Closed Principle, and demonstrates how plugin‑based micro‑kernel architectures, adapter patterns, and nature‑based modeling (as in Eclipse) enable flexible, self‑service platform development while reducing code coupling and maintenance overhead.

EclipseExtension PointsSOA
0 likes · 19 min read
How Extension Points Empower Scalable Platform Architecture
Top Architect
Top Architect
Mar 1, 2023 · Fundamentals

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

This article explains why clean code is essential for productivity, outlines naming conventions, class design, SOLID principles, function responsibilities, parameter handling, and testing practices such as TDD and the FIRST principles, providing concrete examples and refactoring snippets to help developers write maintainable, high‑quality software.

clean codesoftware designtesting
0 likes · 15 min read
Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines
DataFunSummit
DataFunSummit
Feb 26, 2023 · Backend Development

Common Code Smells and Optimization Practices in Backend Development

This article examines typical code quality issues such as meaningless naming, overly long methods, inefficient batch operations, improper dependency handling, excessive parameters, duplicated logic, and offers concrete refactoring examples and best‑practice guidelines to improve maintainability and performance of backend Java code.

Javabest practicescode quality
0 likes · 14 min read
Common Code Smells and Optimization Practices in Backend Development
macrozheng
macrozheng
Feb 23, 2023 · Fundamentals

Master Java Class Naming: 10 Proven Patterns for Clean Code

This article explores common Java class naming conventions across ten categories—management, propagation, callbacks, monitoring, memory, filtering, structure, design patterns, parsing, and networking—providing clear examples and best‑practice tips to make your code more readable and professional.

BackendJavaclass naming
0 likes · 18 min read
Master Java Class Naming: 10 Proven Patterns for Clean Code
21CTO
21CTO
Feb 18, 2023 · Backend Development

Can Modular Monoliths Outperform Microservices? Exploring Spring Modulith

This article examines how modern modular monoliths, especially Spring Modulith, can provide scalable, low‑overhead alternatives to microservices by isolating modules, reducing remote calls, and simplifying deployment while addressing common concerns about complexity and performance.

Backend ArchitectureSpring Modulithmodular monolith
0 likes · 13 min read
Can Modular Monoliths Outperform Microservices? Exploring Spring Modulith
Java Architect Essentials
Java Architect Essentials
Feb 15, 2023 · Industry Insights

How Sustainable Architecture Can Transform Software Delivery in the Agile Era

The article explains the emerging concept of sustainable (continuous) software architecture, outlines six practical principles for designing architectures with product thinking, quality‑attribute focus, just‑in‑time decisions, modularity, and operational considerations, compares it with traditional methods, and illustrates its role in agile and DevOps environments.

Continuous ArchitectureDevOpsSustainable Architecture
0 likes · 8 min read
How Sustainable Architecture Can Transform Software Delivery in the Agile Era
Architects Research Society
Architects Research Society
Feb 10, 2023 · Fundamentals

Understanding Hexagonal Architecture: Principles and Implementation Example

The article explains the three core principles of Hexagonal (Ports‑and‑Adapters) Architecture, illustrates how to separate application, domain, and infrastructure code with concrete C# examples, and shows how this separation improves testability, dependency inversion, and modular design.

Dependency InversionDomain-Driven DesignHexagonal Architecture
0 likes · 18 min read
Understanding Hexagonal Architecture: Principles and Implementation Example
Top Architect
Top Architect
Feb 8, 2023 · Fundamentals

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

This article explains why clean code matters and provides practical guidelines on naming, class design, function decomposition, SOLID principles, testing strategies such as TDD and FIRST, as well as tooling like SonarLint to improve code quality and maintainability.

SOLID principlesclean codenaming conventions
0 likes · 18 min read
Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines
JavaEdge
JavaEdge
Feb 7, 2023 · Fundamentals

How to Safeguard Your Code Against Unintended Modifications

The article explains how shared mutable state, such as global or static variables, can cause hard‑to‑debug bugs in multithreaded Java applications, and demonstrates that adopting immutability, pure functions, and event‑sourcing principles eliminates these issues, offering concrete coding guidelines and examples.

Javafunctional programmingimmutability
0 likes · 10 min read
How to Safeguard Your Code Against Unintended Modifications
macrozheng
macrozheng
Feb 3, 2023 · Fundamentals

Why Clean Code Matters: Practical Tips for Naming, Classes, Functions, and Tests

This article explains why clean, well‑structured code is essential for productivity and project success, and provides concrete guidance on naming, class design, function composition, testing practices, and tools to help developers write maintainable, high‑quality software.

best practicesclean coderefactoring
0 likes · 13 min read
Why Clean Code Matters: Practical Tips for Naming, Classes, Functions, and Tests
Code Ape Tech Column
Code Ape Tech Column
Jan 29, 2023 · Backend Development

Microservice Splitting Strategies: Expert Perspectives and Practical Guidelines

The article discusses various expert approaches to microservice decomposition, highlighting vertical and horizontal splits, business logic, stability, reliability, performance considerations, and team size implications, offering practical guidance for backend architects in design.

Backend ArchitectureTeam Organizationservice decomposition
0 likes · 10 min read
Microservice Splitting Strategies: Expert Perspectives and Practical Guidelines
JavaEdge
JavaEdge
Jan 27, 2023 · Fundamentals

Why Your Java Code Feels Procedural and How to Adopt Multi‑Paradigm Design

Even though Java promotes object‑oriented programming, many developers write code that looks like procedural C, mixing business logic across layers; this article explains programming paradigms, their constraints, and how to combine structured, object‑oriented, and functional techniques into a clean multi‑paradigm design.

JavaObject-OrientedProgramming Paradigms
0 likes · 9 min read
Why Your Java Code Feels Procedural and How to Adopt Multi‑Paradigm Design
政采云技术
政采云技术
Dec 22, 2022 · Fundamentals

Understanding Refactoring: Motivation, Standards, and a Practical Java Example

This article explains why refactoring is essential for maintainable code, outlines quality standards such as readability and extensibility, and walks through a concrete Java example that evolves from a monolithic statement method to a clean, modular design using extract method, move method, and replace‑temp‑with‑query techniques.

Javaclean codecode quality
0 likes · 16 min read
Understanding Refactoring: Motivation, Standards, and a Practical Java Example
ITPUB
ITPUB
Nov 28, 2022 · Backend Development

When Should You Use Domain Services in Go? A Practical DDD Guide

This article explains the role of domain services in Go‑based Domain‑Driven Design, outlines three situations where they are appropriate, shows how to implement them statelessly, recommends functional package organization, and demonstrates dependency inversion with interfaces and infrastructure implementations.

Backend ArchitectureDDDDomain Services
0 likes · 13 min read
When Should You Use Domain Services in Go? A Practical DDD Guide
Architecture & Thinking
Architecture & Thinking
Nov 24, 2022 · Backend Development

How DDD Can Tame Complex Microservice Architectures

This article explains how Domain‑Driven Design (DDD) guides the strategic and tactical decomposition of monolithic applications into well‑bounded microservices, outlines its benefits such as a unified language and clearer domain boundaries, and provides concrete code examples from a membership‑center service.

BackendDDDDomain-Driven Design
0 likes · 14 min read
How DDD Can Tame Complex Microservice Architectures
Open Source Linux
Open Source Linux
Nov 21, 2022 · Fundamentals

Master Core Programming Principles: KISS, DRY, YAGNI and More

This article compiles essential programming principles such as KISS, DRY, YAGNI, and others, explaining their origins, practical advice, and additional design guidelines to help developers write simpler, more maintainable, and less error‑prone code.

DRYKISSYAGNI
0 likes · 10 min read
Master Core Programming Principles: KISS, DRY, YAGNI and More
21CTO
21CTO
Nov 17, 2022 · Fundamentals

Why Clean Code Principles Matter for Every Developer

This article shares practical takeaways from the book "Clean Code", covering why messy code hurts productivity, how to name variables and functions better, essential class design rules, error handling, refactoring tips, and a brief look at concurrency and iterative development.

clean codecoding standardsrefactoring
0 likes · 9 min read
Why Clean Code Principles Matter for Every Developer
DaTaobao Tech
DaTaobao Tech
Nov 2, 2022 · Frontend Development

Insights on Front‑End Architecture and the Role of a Front‑End Architect

The senior Taobao front‑end engineer describes how building internal tools like AppDevTools and mtop.js shaped his view of front‑end architecture, outlining the architect’s role in linking product, design, and engineering, creating clear, flexible solutions, guiding teams through systematic problem‑solving, and fostering continuous learning and communication.

Frontend ArchitectureSSRbest practices
0 likes · 9 min read
Insights on Front‑End Architecture and the Role of a Front‑End Architect
Top Architect
Top Architect
Sep 26, 2022 · Fundamentals

Key Programming Principles: KISS, DRY, YAGNI and Other Guidelines

This article explains essential software design principles such as KISS, DRY, YAGNI, and additional guidelines for writing maintainable, simple code, while also warning against over‑engineering and emphasizing the importance of testing, clear communication, and minimal coupling in everyday programming practice.

DRYKISSSoftware Engineering
0 likes · 11 min read
Key Programming Principles: KISS, DRY, YAGNI and Other Guidelines
Architects' Tech Alliance
Architects' Tech Alliance
Sep 3, 2022 · Fundamentals

Architectural Musings: Defining Architecture and Its Role in Software Development

This article explores the concept of architecture—from its origins in human societal division of labor to its application in software design—highlighting why recognizing problems, defining boundaries, and splitting responsibilities are essential for building effective, scalable systems that serve human needs.

System Designbusiness analysisorganizational structure
0 likes · 60 min read
Architectural Musings: Defining Architecture and Its Role in Software Development
DaTaobao Tech
DaTaobao Tech
Sep 2, 2022 · Backend Development

Debugging Cloud Storage Middleware Migration Issues in Backend Development

The team resolved export failures caused by a deprecated cloud‑storage middleware by adding a new method that generates user‑specific sub‑paths and saves files, but recognized security, configurability, and maintainability issues, recommending configurable buckets, thorough permission reviews, and reusable design when migrating third‑party dependencies.

BackendCode reviewcloud storage
0 likes · 7 min read
Debugging Cloud Storage Middleware Migration Issues in Backend Development
Continuous Delivery 2.0
Continuous Delivery 2.0
Aug 18, 2022 · Backend Development

Why Code Review Matters and How to Apply Engineering Best Practices in Backend Development

The article argues that code review is essential for software quality, critiques common shortcomings in engineering practice, and presents principles such as simplicity, composition, transparency, and disciplined logging, illustrated with Go code examples, to guide developers toward maintainable, scalable backend systems.

BackendGolangsoftware design
0 likes · 39 min read
Why Code Review Matters and How to Apply Engineering Best Practices in Backend Development
Python Programming Learning Circle
Python Programming Learning Circle
Jul 27, 2022 · Fundamentals

Modular Programming Concepts and Benefits in Python

This article explains the modular programming philosophy in Python, describing the differences between modules and packages, the advantages of modular design such as improved readability, reusability, and collaborative development, and includes illustrative diagrams and promotional resources for further learning.

Modular ProgrammingModulesPackages
0 likes · 6 min read
Modular Programming Concepts and Benefits in Python
21CTO
21CTO
Jul 17, 2022 · Fundamentals

Why Software Design Docs Matter: Master UML Modeling for Clear Architecture

This article explains the fundamentals of software design documentation, showing how UML modeling—class, sequence, component, deployment, use‑case, state, and activity diagrams—captures domain problems and system structure across requirement, high‑level, and detailed design phases, enabling architects to communicate intent to diverse stakeholders.

DocumentationModelingUML
0 likes · 13 min read
Why Software Design Docs Matter: Master UML Modeling for Clear Architecture
macrozheng
macrozheng
Jul 6, 2022 · Backend Development

Master Domain-Driven Design: From Theory to a Complete Java DDD Demo

This article explains the fundamentals of Domain‑Driven Design, compares it with traditional MVC, details layered architecture, data transformation objects, core concepts like aggregates and domain events, and provides a full Java SpringBoot DDD demo with code, project structure, database schema, and deployment steps.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 32 min read
Master Domain-Driven Design: From Theory to a Complete Java DDD Demo
FunTester
FunTester
May 24, 2022 · Fundamentals

Why Abstract Thinking Is the Key to Scalable Software Design

The article explains how abstract thinking—extracting common traits, ignoring irrelevant details, and managing hierarchical levels—empowers programmers to write more reusable, maintainable code, illustrated with philosophical analogies, OOP examples, and concrete refactoring of type‑casting logic.

abstractioncode qualityobject‑oriented programming
0 likes · 10 min read
Why Abstract Thinking Is the Key to Scalable Software Design
Qunar Tech Salon
Qunar Tech Salon
May 5, 2022 · Backend Development

Applying Domain-Driven Design (DDD) to Hotel Transaction Systems: Architecture and Code Implementation

This article explains how Domain-Driven Design is applied to a hotel transaction platform, detailing a four‑layer loose DDD architecture, the responsibilities of each layer, code implementation examples, and strategies for maintaining consistency across aggregates using events and factories.

DDDDomain-Driven DesignEvent-driven
0 likes · 9 min read
Applying Domain-Driven Design (DDD) to Hotel Transaction Systems: Architecture and Code Implementation
Architect's Journey
Architect's Journey
Apr 27, 2022 · R&D Management

Essential Architecture Terms Every Architect Should Know

This article compiles core architectural concepts—including ROI, SOLID principles, system splitting, isolation, ACID, CAP/BASE, distributed transactions, and capacity estimation—explaining their definitions, practical examples, trade‑offs, and how they guide architects in making informed technical decisions.

CAP theoremDistributed TransactionsSOLID
0 likes · 19 min read
Essential Architecture Terms Every Architect Should Know
Architecture Digest
Architecture Digest
Apr 27, 2022 · Backend Development

Application Layering Best Practices and Alibaba Specification

The article discusses common pitfalls in application layering, presents the Alibaba coding guideline for multi‑layer architecture, proposes an optimized layering model with clear responsibilities for controller, service, manager, and DAO layers, and explains domain model conversions to improve maintainability and reuse.

Alibaba guidelinesBackend DevelopmentService Layer
0 likes · 9 min read
Application Layering Best Practices and Alibaba Specification
21CTO
21CTO
Apr 26, 2022 · Fundamentals

Why Software Complexity Grows and How to Tame It: From Tactical Tornadoes to Strategic Design

This article explores the nature of software complexity, its rational and sensory definitions, common symptoms such as change amplification, cognitive load and unknown unknowns, and contrasts tactical programming practices with strategic design approaches to help engineers manage and reduce complexity over time.

architectural patternscode qualitysoftware complexity
0 likes · 21 min read
Why Software Complexity Grows and How to Tame It: From Tactical Tornadoes to Strategic Design
Alibaba Terminal Technology
Alibaba Terminal Technology
Apr 21, 2022 · Fundamentals

Why Software Complexity Grows: From Tactical Tornadoes to Strategic Design

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

architecturecomplexitysoftware design
0 likes · 20 min read
Why Software Complexity Grows: From Tactical Tornadoes to Strategic Design
Liangxu Linux
Liangxu Linux
Apr 10, 2022 · Fundamentals

What Makes Code Truly Good? 10 Essential Characteristics Every Engineer Should Master

This article outlines ten key attributes of high‑quality code—robustness, efficiency, simplicity, brevity, testability, reusability, portability, observability, operational readiness, and scalability—while contrasting them with common bad‑code patterns and explaining how solid requirement analysis, system design, testing, and continuous iteration produce truly good software.

Software Engineeringbest practicescode quality
0 likes · 15 min read
What Makes Code Truly Good? 10 Essential Characteristics Every Engineer Should Master
Wukong Talks Architecture
Wukong Talks Architecture
Mar 25, 2022 · Fundamentals

Good Code Characteristics and How to Achieve High‑Quality Software

The article outlines ten essential characteristics of good code, contrasts them with common bad‑code patterns, and explains how thorough requirement analysis, system design, testing, and operational practices together produce high‑quality software, while also promoting a related book giveaway.

code qualitysoftware designtesting
0 likes · 13 min read
Good Code Characteristics and How to Achieve High‑Quality Software
Programmer DD
Programmer DD
Mar 22, 2022 · Fundamentals

What Makes Code Truly Good? 10 Essential Traits Every Engineer Should Master

The article outlines ten key characteristics of high‑quality code—robustness, efficiency, simplicity, brevity, testability, reusability, portability, observability, operability, and scalability—while contrasting them with common bad‑code examples and emphasizing the importance of thorough analysis, design, testing, and continuous improvement throughout the software development lifecycle.

Software Engineeringcode qualitysoftware design
0 likes · 14 min read
What Makes Code Truly Good? 10 Essential Traits Every Engineer Should Master
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 13, 2022 · Fundamentals

Mastering UML: From Project Kickoff to System Design with Real-World Cases

This comprehensive guide walks you through selecting and applying the right UML diagrams at each project stage—from initial scope and feasibility studies, through requirement analysis and use‑case modeling, to system design, domain modeling, and detailed interaction diagrams—illustrated with two practical case studies.

Sequence DiagramSystem DesignUML
0 likes · 23 min read
Mastering UML: From Project Kickoff to System Design with Real-World Cases
21CTO
21CTO
Mar 3, 2022 · Fundamentals

Why Software Complexity Is Killing Developers and How to Tame It

The article explores the nature of software complexity, contrasting rational metrics like McCabe cyclomatic complexity with the subjective view of John Ousterhout, identifies symptoms such as change amplification, cognitive load and unknown unknowns, and proposes strategic design over tactical programming to control architectural decay.

architectural governancesoftware complexitysoftware design
0 likes · 21 min read
Why Software Complexity Is Killing Developers and How to Tame It
Alibaba Terminal Technology
Alibaba Terminal Technology
Feb 21, 2022 · Frontend Development

How a Frontend Architect Became a ‘Chef’ to Serve Teams and Tame Technical Debt

This article follows a front‑end architect who treats architecture like cooking, writes massive amounts of code, builds a Node‑based framework to bridge front‑end and back‑end, tackles legacy system debt, and shares a philosophy that blends technical rigor with service‑oriented mindset.

Developer ExperienceFrontend ArchitectureTechnical Debt
0 likes · 9 min read
How a Frontend Architect Became a ‘Chef’ to Serve Teams and Tame Technical Debt
Baidu Geek Talk
Baidu Geek Talk
Feb 16, 2022 · Fundamentals

SDK Development Best Practices: Design Principles and Coding Standards from Baidu

Baidu’s SDK development guide stresses writing reusable, stable libraries by applying SOLID design principles, exposing errors, ensuring thorough testing, maintaining backward compatibility, minimizing dependencies, and enhancing usability and understandability, while enforcing strict commit linking, Golint checks, branch versioning, and formal code‑review processes.

Baidu EngineeringGo ProgrammingSDK Development
0 likes · 21 min read
SDK Development Best Practices: Design Principles and Coding Standards from Baidu
Code Ape Tech Column
Code Ape Tech Column
Feb 13, 2022 · Fundamentals

30 Architectural Principles for Distributed Systems and Software Design

This article presents thirty concise architectural principles covering simplicity, iterative development, automation, scalability, concurrency, distributed system design, user experience, and practical trade‑offs, offering a comprehensive guide for architects and engineers to build robust, maintainable software.

ScalabilityUser experiencearchitecture
0 likes · 9 min read
30 Architectural Principles for Distributed Systems and Software Design
High Availability Architecture
High Availability Architecture
Jan 20, 2022 · Backend Development

Event-Driven Architecture: Concepts, Scenarios, Patterns, and Practical Implementation

This article explains the fundamentals of event‑driven architecture, outlines when it should be used, describes common patterns such as event notification, state transfer, event sourcing, and CQRS, and provides a detailed example of applying these concepts in a content‑platform microservice system with code snippets and deployment considerations.

BackendCQRSEvent Sourcing
0 likes · 17 min read
Event-Driven Architecture: Concepts, Scenarios, Patterns, and Practical Implementation
HelloTech
HelloTech
Jan 19, 2022 · Fundamentals

Understanding Mid‑Platform Architecture: Concepts, Benefits, and Implementation Patterns

The article explains mid‑platform architecture as an organizational and technical strategy that abstracts reusable components, defines business identities for isolated yet flexible capabilities, and offers three extension patterns—local JAR integration, remote SPI calls, and shared JARs—to balance performance, isolation, and version management while enabling rapid business line onboarding and scalable growth.

Extension PointsSystem Integrationarchitecture
0 likes · 8 min read
Understanding Mid‑Platform Architecture: Concepts, Benefits, and Implementation Patterns
21CTO
21CTO
Jan 3, 2022 · Frontend Development

Unlock Front-End Power with Open-Closed, Functional Programming, and Messaging

This article explores how core software engineering concepts—Open‑Closed Principle, functional programming, and message mechanisms—are applied in modern front‑end development, illustrating each with real‑world frameworks like React, Ant Design, and Redux, and providing code examples to deepen understanding.

Open/Closed Principlefunctional programmingmessage passing
0 likes · 18 min read
Unlock Front-End Power with Open-Closed, Functional Programming, and Messaging