BestHub
Sign in
Tagged articles
401 articles
Page 3 of 5
Top Architect
Top Architect
Dec 16, 2021 · Fundamentals

Object‑Oriented Modeling: From Data Model to Object Model, Composition, Aggregation and Practical Java Examples

This article explains the fundamentals of object‑oriented modeling, contrasting data‑model and object‑model designs, illustrating attribute‑method composition, composition versus aggregation, and providing concrete Java and SQL examples such as a simple Account domain, an eating‑process model, and an open‑source e‑commerce reference.

ModelingObject-Orientedaggregation
0 likes · 14 min read
Object‑Oriented Modeling: From Data Model to Object Model, Composition, Aggregation and Practical Java Examples
Senior Brother's Insights
Senior Brother's Insights
Dec 13, 2021 · Fundamentals

Why Good Code Structure Matters and How to Build One

A well‑designed code structure reduces hand‑off friction, eases collaboration, and turns tangled, messy code into a clear, modular system by applying single‑responsibility, reusability, and explicit definitions across layers such as Model, Util, Service, Dao, and Controller.

ModelService Layercode architecture
0 likes · 9 min read
Why Good Code Structure Matters and How to Build One
Top Architect
Top Architect
Dec 7, 2021 · Mobile Development

Cross‑Platform Architecture for WeChat Pay: Reducing Bugs and Boosting Productivity

The article describes how a C++‑based cross‑platform framework, combined with UseCase abstraction, routing mechanisms, unified network request handling, and strict data‑transfer rules, solved iOS/Android inconsistencies in WeChat Pay, cut code size by 45%, kept crash rates stable, and dramatically improved development efficiency.

CWeChat Paycross-platform
0 likes · 14 min read
Cross‑Platform Architecture for WeChat Pay: Reducing Bugs and Boosting Productivity
Liangxu Linux
Liangxu Linux
Dec 1, 2021 · Fundamentals

Master Essential Software Design Principles: From KISS to SOLID

This article explains core software design principles—including KISS, DRY, high cohesion/low coupling, separation of concerns, YAGNI, the Boy‑Scout rule, and the SOLID rules—detailing their motivations, practical guidelines, benefits, and common pitfalls for creating maintainable, flexible code.

DRYKISSSOLID
0 likes · 27 min read
Master Essential Software Design Principles: From KISS to SOLID
JavaEdge
JavaEdge
Nov 28, 2021 · Fundamentals

How to Spot and Eliminate Hidden Duplicate Code in Your Projects

The article explains why copy‑pasting code (CV) creates maintenance nightmares, shows how to identify structural and conditional duplication, and provides concrete refactoring steps—extracting methods, using common interfaces, and applying functional techniques—to achieve DRY and improve code readability.

DRYcode duplicationrefactoring
0 likes · 8 min read
How to Spot and Eliminate Hidden Duplicate Code in Your Projects
Code Ape Tech Column
Code Ape Tech Column
Nov 22, 2021 · Fundamentals

25 Common Code Smells and Their Refactoring Solutions

This article explains twenty‑five typical code smells—such as duplicated code, long methods, large classes, and excessive parameters—and provides concrete refactoring techniques like Extract Method, Extract Class, and Move Method to improve readability, maintainability, and design quality in object‑oriented software.

Object-Orientedclean codecode smell
0 likes · 19 min read
25 Common Code Smells and Their Refactoring Solutions
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 29, 2021 · Fundamentals

25 Common Code Smells and Their Refactoring Solutions

This article lists 25 typical code smells—such as duplicated code, long methods, large classes, and magic numbers—explains why they hinder readability and maintainability, and provides concrete refactoring solutions with Java examples to improve code quality and design.

clean codecode smellsrefactoring
0 likes · 17 min read
25 Common Code Smells and Their Refactoring Solutions
IT Architects Alliance
IT Architects Alliance
Oct 22, 2021 · R&D Management

Key Responsibilities, Skills, and Career Path of an IT Architect

The article outlines the comprehensive role of an IT architect, emphasizing that beyond coding, architects must acquire broad technical experience, business acumen, communication skills, and strategic insight to guide development, influence decisions, and advance toward senior management or entrepreneurship.

IT Architecturebusiness acumencommunication skills
0 likes · 10 min read
Key Responsibilities, Skills, and Career Path of an IT Architect
Python Programming Learning Circle
Python Programming Learning Circle
Oct 15, 2021 · Fundamentals

Improving Code Quality with SOLID Principles, Architecture Patterns, and Refactoring Techniques

This article explains how applying the five SOLID principles, choosing appropriate system architectures, using clear naming, drawing diagrams, and refactoring code—including guard clauses, responsibility‑chain patterns, and composition over inheritance—can dramatically improve Python program design and maintainability.

PythonSOLIDarchitecture
0 likes · 21 min read
Improving Code Quality with SOLID Principles, Architecture Patterns, and Refactoring Techniques
Big Data Technology Architecture
Big Data Technology Architecture
Oct 14, 2021 · Backend Development

Effective Code Review and Software Design Principles for Go Backend Development

This article shares practical insights on why engineers and leaders must conduct code reviews, identifies common causes of poor code such as duplication and premature decisions, and presents concrete design principles—including simplicity, composition, transparency, and disciplined logging—illustrated with Go code examples to help teams build maintainable, high‑quality backend systems.

Backend EngineeringCode reviewGolang
0 likes · 39 min read
Effective Code Review and Software Design Principles for Go Backend Development
IT Architects Alliance
IT Architects Alliance
Oct 12, 2021 · R&D Management

Mastering Architecture Diagrams: A Practical C4 Methodology Guide

This article presents a practical methodology for creating clear, effective software architecture diagrams, explaining fundamental concepts, various view types such as context, container, component, and class diagrams, and offering tips on audience targeting, common pitfalls, and tool recommendations to improve communication among stakeholders.

C4 ModelDiagrammingSystem Architecture
0 likes · 11 min read
Mastering Architecture Diagrams: A Practical C4 Methodology Guide
Laravel Tech Community
Laravel Tech Community
Oct 8, 2021 · Backend Development

PHP: The Worst Language? Exploring Design Philosophies and the “Worse is Better” Approach

The article examines PHP’s reputation as a poorly designed language, contrasts the “Right Way” and “Worse is Better” software design philosophies, and explains how PHP’s simplicity, correctness, consistency, and completeness allow it to remain a viable backend technology despite its flaws.

Worse is Betterbackend-developmentprogramming-languages
0 likes · 13 min read
PHP: The Worst Language? Exploring Design Philosophies and the “Worse is Better” Approach
IT Architects Alliance
IT Architects Alliance
Oct 7, 2021 · Fundamentals

Understanding Entity and Value Object Concepts in Message Domain Design

This article explains the core characteristics of entities—identity and continuity—using domain‑driven design principles, analyzes why a Message should be modeled as an entity, and argues that senders and recipients are better represented as entities rather than value objects in a messaging system.

Domain-Driven DesignEntityMessage Architecture
0 likes · 11 min read
Understanding Entity and Value Object Concepts in Message Domain Design
Java Architect Essentials
Java Architect Essentials
Sep 25, 2021 · Fundamentals

Why Long Classes Are Problematic and How to Refactor Them

The article explains why excessively long classes violate design principles, cause readability and maintenance issues, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and split responsibilities for cleaner, more maintainable code.

IDEAcode qualityrefactoring
0 likes · 9 min read
Why Long Classes Are Problematic and How to Refactor Them
Architects Research Society
Architects Research Society
Sep 19, 2021 · Fundamentals

Understanding UML Associations, Aggregations, Compositions, Generalization and Specialization

This article explains UML relationship types—including association, aggregation, composition, generalization and specialization—by describing their definitions, visual notations, multiplicity, role names, and real‑world examples, helping readers distinguish each concept and apply them in software modeling.

AssociationGeneralizationSpecialization
0 likes · 7 min read
Understanding UML Associations, Aggregations, Compositions, Generalization and Specialization
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 18, 2021 · Fundamentals

Mastering Software Design: Modeling Architecture with UML

This article explains how software architects can use UML modeling and design documentation to capture both functional and non‑functional requirements, communicate with stakeholders, and guide developers through requirement analysis, high‑level design, and detailed design phases.

ModelingSoftware EngineeringUML
0 likes · 13 min read
Mastering Software Design: Modeling Architecture with UML
ITPUB
ITPUB
Sep 7, 2021 · Fundamentals

How to Write Clean, Maintainable Code: Principles and Practical Tips

This article compiles practical guidelines and personal experiences on writing clean, maintainable code, covering principles such as eliminating duplication, separating concerns, unifying abstraction levels, function design, naming, unit testing, and broader software‑engineering concepts to reduce mental load and improve code quality.

abstractionclean codecoding best practices
0 likes · 24 min read
How to Write Clean, Maintainable Code: Principles and Practical Tips
Architects Research Society
Architects Research Society
Sep 5, 2021 · Fundamentals

An Introduction to Domain-Driven Design (DDD) Patterns and Practices

This article explains the core concepts, patterns, and architectural styles of Domain-Driven Design, covering model‑driven design, bounded contexts, layered and hexagonal architectures, building blocks such as entities, value objects, aggregates, repositories, factories, and services, with practical examples and diagrams.

BackendDDDDomain-Driven Design
0 likes · 28 min read
An Introduction to Domain-Driven Design (DDD) Patterns and Practices
Architects Research Society
Architects Research Society
Aug 23, 2021 · Fundamentals

Agile Architecture Strategies for Scaling Agile Development

This article explains how agile architecture differs from traditional approaches, outlines the full lifecycle of agile architecture, defines responsibilities, introduces the role of an architecture owner, and provides practical guidance for modeling, scaling, communicating, and evolving architecture in large‑scale agile projects while avoiding over‑engineering.

Agile Architecturearchitecture modelingscaling
0 likes · 40 min read
Agile Architecture Strategies for Scaling Agile Development
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 16, 2021 · Fundamentals

Why Refactoring Matters: Practical Tips and Code Smell Solutions

This article, based on the author’s experience and Martin Fowler’s book, explains what refactoring is, why it’s essential, how to spot code smells, and provides concrete principles and JavaScript examples to improve code design, readability, and maintainability without focusing on performance.

JavaScriptbest practicescode smells
0 likes · 27 min read
Why Refactoring Matters: Practical Tips and Code Smell Solutions
Architect's Journey
Architect's Journey
Aug 13, 2021 · R&D Management

How a Competent Tech Lead Should Analyze a PRD

The article explains why PRD analysis is crucial for developers, outlines three practical steps—clarifying project goals, continuously focusing on the right work, and designing first—and provides concrete questions, domain‑modeling techniques, and activity‑diagram examples to help technical leads turn product solutions into solid technical designs.

Domain ModelingMVPPRD analysis
0 likes · 13 min read
How a Competent Tech Lead Should Analyze a PRD
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 7, 2021 · Backend Development

Why Microservices Matter: From Monoliths to Scalable Architecture

This article explains the fundamentals of microservice architecture, contrasts it with monolithic designs, outlines the problems microservices solve, lists their advantages and drawbacks, provides a hands‑on code example, and describes practical strategies for splitting and migrating legacy systems.

BackendMicroservicesarchitecture
0 likes · 19 min read
Why Microservices Matter: From Monoliths to Scalable Architecture
Wukong Talks Architecture
Wukong Talks Architecture
Jul 12, 2021 · Fundamentals

25 Common Code Smells and Refactoring Techniques

This article lists 25 typical code smells such as duplicated code, long methods, large classes, and provides concrete Java examples and refactoring strategies like Extract Method, Extract Class, Move Method, and design recommendations to improve readability, maintainability, and extensibility.

bad practiceclean codecode smell
0 likes · 23 min read
25 Common Code Smells and Refactoring Techniques
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 11, 2021 · Fundamentals

How to Design Large-Scale Systems: From Business to Technical Architecture

This article explains the fundamental differences between large and simple systems, clarifies why large-system design is more than just distributed design, and outlines a step-by-step approach covering business, system, and technology layers, including business, application, data, and technical architecture.

large-scale architecturesoftware designsystem engineering
0 likes · 8 min read
How to Design Large-Scale Systems: From Business to Technical Architecture
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 6, 2021 · Backend Development

Mastering Layered Architecture: Design Principles and Java Implementation

This article outlines the concepts, advantages, drawbacks, and design guidelines of layered architecture, explores logical, presentation, service, and physical layers, and demonstrates a Java implementation with detailed diagrams to help developers build scalable, maintainable systems.

Backend DevelopmentSystem Designlayered architecture
0 likes · 5 min read
Mastering Layered Architecture: Design Principles and Java Implementation
ELab Team
ELab Team
Jun 30, 2021 · Frontend Development

Why Abstraction Leaks Undermine Your Front‑End Projects—and How to Fix Them

This article explores the concept of abstraction leaks in software design, especially within front‑end development and low‑code platforms, explains why they occur, illustrates common symptoms, and offers practical strategies for developers to manage, redesign, or mitigate such leaks.

abstractionarchitectureleaky abstractions
0 likes · 25 min read
Why Abstraction Leaks Undermine Your Front‑End Projects—and How to Fix Them
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 28, 2021 · Fundamentals

How to Build Effective Domain Models for E‑Commerce Systems

This article explains the purpose, definition, and step‑by‑step process of creating domain models for e‑commerce shopping flows, covering concept identification, relationship mapping, state modeling, class and state diagrams, model review, and introduces the accompanying conceptual architecture visuals.

Domain ModelingUMLconceptual architecture
0 likes · 7 min read
How to Build Effective Domain Models for E‑Commerce Systems
Architect
Architect
Jun 27, 2021 · Backend Development

Understanding Microservices Architecture: Principles, Benefits, Challenges, and Implementation Strategies

This article explains microservices architecture, contrasting it with monolithic systems, outlines the problems it solves, lists its advantages and disadvantages, provides a concrete service example with code, and discusses strategies, principles, and patterns for splitting and evolving microservices.

Backend ArchitectureDevOpsservice decomposition
0 likes · 18 min read
Understanding Microservices Architecture: Principles, Benefits, Challenges, and Implementation Strategies
Architecture Digest
Architecture Digest
Jun 23, 2021 · Fundamentals

Business Architecture: Concepts and Practical Challenges

The article introduces the concept of business architecture, explaining how abstract architectural design must be grounded in concrete business needs, and discusses the difficulty of bridging design patterns with real‑world value creation, illustrated through a series of explanatory diagrams.

abstractionbusiness architectureimplementation
0 likes · 2 min read
Business Architecture: Concepts and Practical Challenges
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 16, 2021 · Backend Development

Mastering DDD Aggregates: Defining Boundaries for Consistent Design

This article explains the essence of DDD aggregates, why they are needed to enforce business consistency, how to identify proper aggregate boundaries using lifecycle, domain, and scenario‑frequency rules, and provides practical implementation guidance with code examples and architectural tips.

AggregatesBackend ArchitectureDDD
0 likes · 22 min read
Mastering DDD Aggregates: Defining Boundaries for Consistent Design
Top Architect
Top Architect
Jun 4, 2021 · Backend Development

Design and Refactoring of a Rule Engine for User Application Processing

This article describes the design, short‑circuit execution logic, and refactoring of a backend rule engine that evaluates user application criteria using AND/OR relationships, outlines its implementation steps, and discusses its advantages and drawbacks for maintainability.

refactoringrule engineshort-circuit logic
0 likes · 4 min read
Design and Refactoring of a Rule Engine for User Application Processing
Architecture Digest
Architecture Digest
May 25, 2021 · Backend Development

Layered Architecture and Domain‑Driven Design for Java Fresh‑Food E‑Commerce Microservices

This article presents a practical approach to applying layered architecture and Domain‑Driven Design (DDD) in a Java‑based fresh‑food e‑commerce platform, outlining a five‑layer microservice structure, domain partitioning guidelines, and common pitfalls to help teams build maintainable, scalable systems.

DDDJavae‑commerce
0 likes · 18 min read
Layered Architecture and Domain‑Driven Design for Java Fresh‑Food E‑Commerce Microservices
Architect's Journey
Architect's Journey
May 19, 2021 · R&D Management

Essential Diagramming Techniques Every Architect Should Master

The article explains why architects need to master mind maps, UML diagrams (class, sequence, activity, state) and architecture diagrams, outlines key principles for each, provides concrete examples and visual illustrations, and shares practical insights on using these diagrams to improve design communication and business alignment.

DiagrammingModelingUML
0 likes · 11 min read
Essential Diagramming Techniques Every Architect Should Master
IT Architects Alliance
IT Architects Alliance
May 17, 2021 · Industry Insights

How to Craft Clear Architecture Diagrams: A Practical C4 Methodology

This article presents a practical methodology for creating clear software architecture diagrams, explaining core concepts, the 4+1 view classification, common pitfalls, and the C4 model with concrete examples, helping architects choose the right diagram type for their audience and purpose.

C4 ModelDiagramarchitecture
0 likes · 12 min read
How to Craft Clear Architecture Diagrams: A Practical C4 Methodology
KooFE Frontend Team
KooFE Frontend Team
May 12, 2021 · Fundamentals

How to Eliminate Complex Conditionals for Cleaner JavaScript Code

This article explains why complex conditional statements hurt code readability and maintainability, and provides practical techniques—such as avoiding flag parameters, encapsulating conditions, using guard clauses, applying the Null Object pattern, leveraging polymorphism, and employing strategy or command patterns—to simplify JavaScript/TypeScript code and improve overall quality.

TypeScriptclean codeconditional complexity
0 likes · 8 min read
How to Eliminate Complex Conditionals for Cleaner JavaScript Code
DeWu Technology
DeWu Technology
May 7, 2021 · Fundamentals

Software Engineering and PlantUML Practice

The article explains how software‑engineering’s planning‑to‑maintenance lifecycle benefits from UML, then demonstrates using the open‑source textual tool PlantUML to quickly create version‑controlled use‑case, activity (swimlane), state, sequence, and class diagrams, detailing each syntax element and illustrating real‑world examples.

PlantUMLSequence DiagramState Diagram
0 likes · 13 min read
Software Engineering and PlantUML Practice
Selected Java Interview Questions
Selected Java Interview Questions
Apr 28, 2021 · Fundamentals

Why Using Interfaces Improves Software Maintainability

The article explains that employing interfaces in a layered software architecture simplifies future maintenance by allowing changes to be made in a single implementation class, avoiding widespread code modifications across services, DAOs, and actions, and thereby reducing recompilation time and potential errors.

InterfacesJavalayered architecture
0 likes · 5 min read
Why Using Interfaces Improves Software Maintainability
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 23, 2021 · Fundamentals

Software Design Principles: SOLID and Beyond with Java Examples

This article explains the seven core software design principles—Open/Closed, Dependency Inversion, Single Responsibility, Interface Segregation, Liskov Substitution, Law of Demeter, and Composite Reuse—illustrating each with Java code samples, class diagrams, and practical advice for building maintainable systems.

JavaOOPSOLID
0 likes · 26 min read
Software Design Principles: SOLID and Beyond with Java Examples
Liangxu Linux
Liangxu Linux
Apr 21, 2021 · Fundamentals

Why Reusable Code Eludes Us: FP vs OO Through a FizzBuzz Experiment

The article examines why truly reusable code is hard to achieve by contrasting functional programming in F# with object‑oriented programming in C# through a FizzBuzz implementation, highlighting differences in fragmentation, coupling, and flexibility that affect component reuse.

C#F#code-reuse
0 likes · 11 min read
Why Reusable Code Eludes Us: FP vs OO Through a FizzBuzz Experiment
Continuous Delivery 2.0
Continuous Delivery 2.0
Apr 21, 2021 · Fundamentals

Don’t Mock Types You Don’t Own: Risks and Better Alternatives

The article explains why mocking external components you don’t control can introduce maintenance problems, such as hidden bugs and upgrade difficulties, and suggests using real implementations, library‑provided fakes, or wrapper classes instead, while offering code examples and practical guidance.

JavaMockingTest Doubles
0 likes · 5 min read
Don’t Mock Types You Don’t Own: Risks and Better Alternatives
21CTO
21CTO
Apr 14, 2021 · Fundamentals

Why Mastering Abstraction Is the Secret to Cleaner, More Maintainable Code

This article explains how abstract thinking underpins software design, illustrates abstraction with visual and code examples, shows the pitfalls of duplicated code and forced casts, and offers practical habits—reading, summarizing, naming, and domain modeling—to strengthen a developer's abstraction skills.

Code RefactoringDomain Modelingabstraction
0 likes · 24 min read
Why Mastering Abstraction Is the Secret to Cleaner, More Maintainable Code
Architect's Tech Stack
Architect's Tech Stack
Apr 11, 2021 · Fundamentals

Refactoring Principles, Code Smells, and Practical Techniques for Improving Software Design

This article explains the concept of refactoring, why and when to refactor, enumerates common code smells, and presents concrete techniques such as extracting functions, moving methods or fields, and reorganizing class hierarchies to produce cleaner, more maintainable object‑oriented code.

clean codecode smellsobject‑oriented programming
0 likes · 24 min read
Refactoring Principles, Code Smells, and Practical Techniques for Improving Software Design
IT Architects Alliance
IT Architects Alliance
Apr 10, 2021 · Backend Development

DDD Layered Architecture Patterns: Four‑Layer, Five‑Layer, and Hexagonal Approaches

This article reviews the fundamentals of Domain‑Driven Design and layered architecture, explains the role of ubiquitous language and bounded contexts, and compares three classic DDD layering patterns—four‑layer, five‑layer, and hexagonal—highlighting their practical definitions, benefits, drawbacks, and evolution for microservice‑based systems.

DDDsoftware design
0 likes · 19 min read
DDD Layered Architecture Patterns: Four‑Layer, Five‑Layer, and Hexagonal Approaches
Sohu Tech Products
Sohu Tech Products
Apr 7, 2021 · Fundamentals

Functional Programming in Swift: Concepts, Benefits, and Practical Examples

This article explains functional programming concepts, their importance, and how to apply them in Swift through high‑order functions, lazy evaluation, custom operators, and composable image‑filter pipelines, while also addressing common pitfalls such as nested callbacks and OCP violations.

Higher-Order FunctionsLazy EvaluationRxSwift
0 likes · 19 min read
Functional Programming in Swift: Concepts, Benefits, and Practical Examples
Xianyu Technology
Xianyu Technology
Apr 7, 2021 · Backend Development

Xianyu User Growth Task System Architecture and Implementation

Xianyu’s growth team built a modular user‑task system that abstracts diverse growth playbooks into a unified model defined by five dimensions, manages task lifecycles through dedicated services for periods, benefits, and scheduling, and uses strategy and template patterns to enable rapid, reusable, and efficient user‑engagement experiments.

AlibabaTask Systemsoftware design
0 likes · 6 min read
Xianyu User Growth Task System Architecture and Implementation
JD Tech Talk
JD Tech Talk
Mar 29, 2021 · Backend Development

Design and Implementation of a Lightweight Java Workflow Engine

This article explains why a custom lightweight workflow engine was built, outlines its micro‑kernel architecture, demonstrates incremental development from a Hello‑World example to a simple approval process with branching, and discusses future enhancements such as exception handling, persistence, and dynamic graph modification.

JavaProcess EngineWorkflow Engine
0 likes · 23 min read
Design and Implementation of a Lightweight Java Workflow Engine
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 26, 2021 · Fundamentals

Understanding System Architecture: Concepts, Importance, and Common Patterns

This article explains what system (software) architecture is, why it is crucial for handling software complexity, invisibility, changeability and conformity, and reviews common architectural patterns such as client‑server, peer‑to‑peer, MVC, layered, distributed‑cluster, micro‑service, event‑source, and hexagonal designs.

Architecture PatternsSystem Architecturelayered architecture
0 likes · 14 min read
Understanding System Architecture: Concepts, Importance, and Common Patterns
DeWu Technology
DeWu Technology
Mar 26, 2021 · Backend Development

Summary of DDD Layered Architecture for the Bidding Team

The Bidding Team’s DDD layered architecture consolidates all traffic in an Interfaces layer, uses a thin Application service layer to orchestrate use‑cases, places core business rules in Domain aggregates, isolates data access in Infrastructure, adds an Anti‑Corruption adapter, and employs DTOs, entities, and domain events for decoupled, consistent processing.

Anti‑Corruption LayerDDDDomain-Driven Design
0 likes · 12 min read
Summary of DDD Layered Architecture for the Bidding Team
Programmer DD
Programmer DD
Mar 25, 2021 · Fundamentals

Why the Word “User” Is Killing Your Software Design (And How to Fix It)

The article warns that using the vague term “user” in software design creates security flaws and conceptual confusion, illustrated with ticket‑booking, Unix, and SaaS examples, and advises defining precise concepts like “team” and “member” early to avoid costly redesigns.

POSIXSaaSTerminology
0 likes · 7 min read
Why the Word “User” Is Killing Your Software Design (And How to Fix It)
vivo Internet Technology
vivo Internet Technology
Mar 24, 2021 · Backend Development

Componentization vs Serviceization: Definitions, Pros & Cons, and Application Scenarios

The article defines componentization (shared JAR) and serviceization (independent service), compares their performance, cost, maintainability, and resource trade‑offs, outlines ideal use‑cases such as high‑throughput, no‑DB calls versus DB‑access or lower‑concurrency needs, and provides Vivo case studies to guide selection.

Backend ArchitectureComponentizationMicroservices
0 likes · 15 min read
Componentization vs Serviceization: Definitions, Pros & Cons, and Application Scenarios
Architecture Digest
Architecture Digest
Mar 22, 2021 · Fundamentals

DDD Layered Architecture: Four‑Layer, Five‑Layer, and Hexagonal Patterns

This article reviews Domain‑Driven Design and layered architecture fundamentals, then explains three classic DDD layered patterns—four‑layer, five‑layer, and hexagonal architectures—detailing their layers, responsibilities, advantages, drawbacks, and practical adaptations for microservice development.

DDDHexagonal ArchitectureMicroservices
0 likes · 21 min read
DDD Layered Architecture: Four‑Layer, Five‑Layer, and Hexagonal Patterns
Laravel Tech Community
Laravel Tech Community
Mar 17, 2021 · Fundamentals

A Humorous Guide to 23 Classic Design Patterns Illustrated with Dating Analogies

This article humorously explains 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—using playful dating scenarios to illustrate each pattern’s intent, structure, and trade‑offs.

Object-OrientedSoftware Engineeringarchitecture
0 likes · 18 min read
A Humorous Guide to 23 Classic Design Patterns Illustrated with Dating Analogies
Java Interview Crash Guide
Java Interview Crash Guide
Mar 17, 2021 · Fundamentals

Why Naming Matters: Unlocking Code Readability and Design Power

Effective naming is a critical yet often overlooked aspect of software development that boosts code readability, facilitates communication, reduces cognitive load, and even influences design decisions, as illustrated by real-world examples from Alibaba to POJO, along with practical guidelines for variables, functions, classes, packages, and modules.

code readabilityself‑documenting codesoftware design
0 likes · 20 min read
Why Naming Matters: Unlocking Code Readability and Design Power
phodal
phodal
Mar 15, 2021 · Backend Development

Rethinking Layered Architecture: Lessons from Evolving the Coco System

The article chronicles the evolution of Coco's layered architecture, detailing the shift from a monolithic Clean‑Architecture‑inspired design to a modular, plugin‑driven structure, and discusses the trade‑offs of infrastructure layering, code reuse, and future adaptability.

Plugin Systemmodularizationsoftware design
0 likes · 9 min read
Rethinking Layered Architecture: Lessons from Evolving the Coco System
Java Interview Crash Guide
Java Interview Crash Guide
Mar 10, 2021 · Fundamentals

Why Abstract Thinking Is the Secret Weapon for Better Code Design

This article explains how abstract thinking underpins software engineering, covering definitions, the relationship between language and abstraction, levels of abstraction, layered design, the pitfalls of duplicate code and forced casts, and practical ways to strengthen one’s abstract reasoning skills.

ModelingObject-Orientedabstraction
0 likes · 22 min read
Why Abstract Thinking Is the Secret Weapon for Better Code Design
Architecture Digest
Architecture Digest
Mar 3, 2021 · Backend Development

Integrating Domain‑Driven Design with Microservices: Benefits, Drawbacks, and Practical Guidance

This article explains how Domain‑Driven Design complements microservice architecture by addressing functional partitioning, clarifying bounded contexts, and improving scalability, while also discussing microservice drawbacks and practical guidelines for splitting complex systems in modern applications.

Backend ArchitectureDDDDomain Modeling
0 likes · 9 min read
Integrating Domain‑Driven Design with Microservices: Benefits, Drawbacks, and Practical Guidance
Liangxu Linux
Liangxu Linux
Feb 19, 2021 · Fundamentals

Mastering Code Smells: Identify and Refactor Common Bad Practices

This guide explains the most frequent code smells—Long Method, Large Class, Duplicated Code, Long Parameter List, Shotgun Surgery, Speculative Generality, and excessive comments—detailing why they harm readability and maintainability, and provides concrete refactoring techniques with Java examples to produce cleaner, more modular software.

JavaSOLIDbest practices
0 likes · 14 min read
Mastering Code Smells: Identify and Refactor Common Bad Practices
21CTO
21CTO
Feb 6, 2021 · Fundamentals

Why Are Reusable Components So Hard? A FP vs OO FizzBuzz Experiment

The article explores why building truly reusable components is challenging by comparing a concise functional F# implementation of FizzBuzz with a more verbose object‑oriented C# version, highlighting how language paradigms and design assumptions affect modularity, coupling, and extensibility.

CF#component reuse
0 likes · 11 min read
Why Are Reusable Components So Hard? A FP vs OO FizzBuzz Experiment
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 6, 2021 · Fundamentals

Mastering Software Design Docs: A Practical Guide to Effective Specs

This article explains why software design documents are essential, outlines the key sections they should contain, offers concrete writing tips, and provides a step‑by‑step process for creating, reviewing, and iterating on design specs to improve project outcomes and reduce risk.

best practicesdesign specsengineering process
0 likes · 15 min read
Mastering Software Design Docs: A Practical Guide to Effective Specs
Programmer DD
Programmer DD
Jan 27, 2021 · Backend Development

Why Service Layer Interfaces Matter: Boosting Maintainability and Testability

The article explains that while a Service layer may seem unnecessary for simple business logic, it becomes essential as applications grow, offering benefits such as handling complex operations, supporting reuse across controllers, facilitating unit testing, and enabling flexible business logic composition.

Backend ArchitectureService Layercode maintainability
0 likes · 3 min read
Why Service Layer Interfaces Matter: Boosting Maintainability and Testability
Selected Java Interview Questions
Selected Java Interview Questions
Jan 19, 2021 · Backend Development

Designing a Monolithic Application for Future Microservice Migration: Best Practices and Code Structure

The article explains how to design a monolithic Java application with clear business boundaries, modular code organization, MVC layering, and disciplined controller logic so that it can be smoothly refactored into a micro‑service architecture, illustrating the approach with directory trees, package schemes, and sample CommonResult code.

DDDJavaMVC
0 likes · 11 min read
Designing a Monolithic Application for Future Microservice Migration: Best Practices and Code Structure
Architect's Tech Stack
Architect's Tech Stack
Dec 21, 2020 · Fundamentals

Refactoring Principles, Code Smells, and Refactoring Techniques

This article explains the concept of refactoring, its motivations and timing, enumerates common code smells, and provides detailed refactoring techniques—including extracting methods, moving functions, encapsulating data, simplifying conditionals, and handling inheritance—to improve software design and maintainability.

Object-Orientedbest practicesclean code
0 likes · 21 min read
Refactoring Principles, Code Smells, and Refactoring Techniques
ITPUB
ITPUB
Dec 15, 2020 · Fundamentals

Essential Code Review Principles Every Engineer Should Master

This article compiles practical code‑review guidelines, well‑known architecture principles, and personal engineering habits—covering self‑explaining code, DRY, dependency inversion, error handling, testing strategies, and common pitfalls—to help developers write maintainable, high‑quality software.

Code reviewGolangarchitecture principles
0 likes · 46 min read
Essential Code Review Principles Every Engineer Should Master
Selected Java Interview Questions
Selected Java Interview Questions
Dec 6, 2020 · Fundamentals

Principles and Practices for Effective Code Review and Software Engineering

The article presents a comprehensive guide on why developers and leaders must perform code reviews, identifies common pitfalls such as duplicated code, premature optimization and over‑engineered OOP, and offers concrete principles, model‑design advice, and Golang examples to improve code quality and maintainability.

Code reviewGolangSoftware Engineering
0 likes · 42 min read
Principles and Practices for Effective Code Review and Software Engineering
Code Ape Tech Column
Code Ape Tech Column
Dec 1, 2020 · Information Security

Why Calling Everyone a “User” Is a Hidden Security Risk

The article explains how the vague term “user” creates design flaws and security vulnerabilities across domains such as airline booking systems, Unix environments, and SaaS platforms, and argues for precise terminology to avoid costly rework and confused‑deputy attacks.

SecurityTerminologyaccess control
0 likes · 7 min read
Why Calling Everyone a “User” Is a Hidden Security Risk
Top Architect
Top Architect
Nov 16, 2020 · Mobile Development

Building a C++ Cross‑Platform Framework for the WeChat Pay Client

This article describes how a C++‑based cross‑platform framework was created to unify iOS and Android implementations of WeChat Pay, detailing the architectural challenges, the introduction of UseCase‑driven business flow, a routing mechanism, improved network request handling, and standardized data passing that together reduced code size, improved stability, and boosted development productivity.

CMobile DevelopmentWeChat Pay
0 likes · 14 min read
Building a C++ Cross‑Platform Framework for the WeChat Pay Client
Architect
Architect
Nov 7, 2020 · Fundamentals

Understanding System Architecture and Common Architectural Patterns

This article explains the concept of system architecture, why it matters, the challenges it faces such as complexity and changeability, and reviews major architectural patterns—including client‑server, peer‑to‑peer, MVC, layered, micro‑service, event‑source, and hexagonal—providing a solid foundation for designing robust software systems.

System Architecturearchitectural patternssoftware design
0 likes · 16 min read
Understanding System Architecture and Common Architectural Patterns
IT Architects Alliance
IT Architects Alliance
Nov 2, 2020 · Backend Development

How DDD Can Tame Complex Business Logic in Modern Backend Systems

This article explores how Domain‑Driven Design helps the Tongtian Tower platform manage rapidly growing business complexity by separating business and technical concerns, introducing strategic and tactical design, bounded contexts, layered and hexagonal architectures, and complementary patterns such as CQRS and domain primitives.

Backend ArchitectureCQRSDomain Modeling
0 likes · 40 min read
How DDD Can Tame Complex Business Logic in Modern Backend Systems
JD Cloud Developers
JD Cloud Developers
Oct 9, 2020 · Fundamentals

4 Programming Habits to Unlearn for Cleaner, More Efficient Code

This article identifies four common programming patterns—loops, conditional statements, vague variable names, and global scope—that hinder code clarity and maintainability, and shows how to replace them with higher‑order functions, data‑driven structures, purposeful naming, and encapsulation techniques.

Code RefactoringJavaScriptfunctional programming
0 likes · 9 min read
4 Programming Habits to Unlearn for Cleaner, More Efficient Code
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Oct 5, 2020 · Cloud Native

Should Microservices Be Your Default Architecture? Key Questions to Ask

Before defaulting to a microservices architecture, developers should evaluate whether their application is large enough, truly needs component scaling, can handle cross-service transactions, and can tolerate increased latency and complexity, as these factors determine if microservices will add value or unnecessary overhead.

BackendMicroservicescloud-native
0 likes · 7 min read
Should Microservices Be Your Default Architecture? Key Questions to Ask
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Oct 2, 2020 · Backend Development

How to Split Microservices: 3 Expert Strategies for Effective Service Decomposition

This article compares three seasoned experts' approaches to microservice splitting—vertical vs. horizontal, business‑driven, stability‑driven, and performance‑driven—highlighting trade‑offs, team size considerations, and practical guidelines for achieving scalable, maintainable architectures.

Backend ArchitectureMicroservicesTeam Organization
0 likes · 9 min read
How to Split Microservices: 3 Expert Strategies for Effective Service Decomposition
Programmer DD
Programmer DD
Sep 28, 2020 · Fundamentals

UML Relationship Cheat Sheet: From Dependency to Realization

This article explains the six core UML relationship types—Dependency, Association, Aggregation, Composition, Generalization, and Realization—detailing their semantics, visual notations, code representations in Java/C++, and practical distinctions such as lifecycle ownership and usage contexts.

Object-OrientedUMLaggregation
0 likes · 13 min read
UML Relationship Cheat Sheet: From Dependency to Realization
Programmer DD
Programmer DD
Sep 25, 2020 · Fundamentals

Why Your Code Is Overrun by if‑else and How to Refactor It Effectively

The article explains why developers often end up with excessive if‑else statements, outlines the drawbacks of deep nesting, and presents practical refactoring techniques—including condition merging, early exits, and polymorphism—to produce cleaner, more maintainable code.

Code RefactoringPolymorphismif-else
0 likes · 12 min read
Why Your Code Is Overrun by if‑else and How to Refactor It Effectively
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 20, 2020 · Fundamentals

How Git’s First 1,000-Line Commit Shaped Its Core Design

An in‑depth exploration of Git’s initial 1,000‑line source code reveals the foundational design principles—workspace, index, objects, and three core object types—showing how early implementations of init‑db, update‑cache, write‑tree, and commit‑tree established the powerful, distributed version‑control system we use today.

Version Controlgit internalssoftware design
0 likes · 19 min read
How Git’s First 1,000-Line Commit Shaped Its Core Design
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Sep 18, 2020 · Fundamentals

Linux SCSI Subsystem Architecture and Design Framework

The article thoroughly examines the Linux SCSI subsystem architecture, illustrating how abstract hardware topology—hosts, channels, IDs, and LUNs—is modeled in software through structs such as scsi_host and scsi_device, and detailing initialization, scanning, path establishment, power management, and block‑layer integration to guide kernel storage driver design.

Block LayerData StructuresLinux kernel
0 likes · 20 min read
Linux SCSI Subsystem Architecture and Design Framework
Top Architect
Top Architect
Sep 15, 2020 · Fundamentals

Generating UML Class Diagrams in IntelliJ IDEA

This tutorial explains how to use IntelliJ IDEA's built‑in Diagram plugin to automatically generate UML class diagrams for Java classes, covering configuration steps, shortcut keys, example screenshots, and the tool's limitations for software design documentation.

DiagramIDE pluginIntelliJ IDEA
0 likes · 4 min read
Generating UML Class Diagrams in IntelliJ IDEA
Programmer DD
Programmer DD
Sep 9, 2020 · Fundamentals

Debunking OOP Myths: Does Object‑Oriented Design Really Hurt Performance?

This article examines the widespread popularity of object‑oriented programming, dispels two common myths— that OOP inevitably slows down applications and that using an OOP language automatically means practicing OOP—by presenting performance data, real‑world examples, and a Java procedural code sample.

object‑oriented programmingprogramming mythssoftware design
0 likes · 10 min read
Debunking OOP Myths: Does Object‑Oriented Design Really Hurt Performance?
Architect
Architect
Aug 17, 2020 · Backend Development

Various Approaches to Microservice Decomposition

The article examines microservice architecture as an abstract concept and presents three practical decomposition strategies—vertical/horizontal business split, business‑driven and team‑oriented considerations, and criteria based on logic, stability, reliability and performance—while also discussing cost, release frequency, and team size implications.

Backend ArchitectureTeam Organizationservice decomposition
0 likes · 8 min read
Various Approaches to Microservice Decomposition
Java Captain
Java Captain
Aug 16, 2020 · Fundamentals

Why Classes Should Not Be Too Long and How to Refactor Overgrown Classes

The article explains why excessively long classes with many responsibilities hinder readability and extensibility, outlines the problems of redundant code and SRP violations, and provides practical refactoring techniques—such as extracting methods, moving members, and creating new classes—using IntelliJ IDEA.

IntelliJ IDEAclass designcode quality
0 likes · 11 min read
Why Classes Should Not Be Too Long and How to Refactor Overgrown Classes
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Aug 13, 2020 · Backend Development

How to Master Business Architecture with Layered and Domain‑Driven Design

This article explains how business architecture controls system complexity through layered structures and domain‑driven design, compares traditional three‑tier and microservice architectures, highlights common pitfalls, and offers a lightweight domain‑centric approach for scalable, maintainable backend systems.

Domain-Driven DesignMicroservicesbusiness architecture
0 likes · 8 min read
How to Master Business Architecture with Layered and Domain‑Driven Design
Liangxu Linux
Liangxu Linux
Aug 2, 2020 · Information Security

Why the Word “User” Is a Hidden Security Risk in Software Design

The article explains how the vague term “user” leads to design flaws and security vulnerabilities across systems like ticket‑booking platforms, Unix, and SaaS, and argues that precise terminology and early conceptual planning can prevent costly rework.

access controlbest practicessoftware design
0 likes · 8 min read
Why the Word “User” Is a Hidden Security Risk in Software Design
QQ Music Frontend Team
QQ Music Frontend Team
Jul 20, 2020 · Fundamentals

Why Refactoring Matters: Principles, Timing, and Practical Techniques

Refactoring improves code understandability and reduces maintenance costs by reorganizing internal structure without changing behavior, and this guide explains its purpose, timing, principles, common code smells, measurement metrics, and practical techniques across data, statement, subroutine, class, and system levels.

best practicescode qualityrefactoring
0 likes · 20 min read
Why Refactoring Matters: Principles, Timing, and Practical Techniques
Top Architect
Top Architect
Jul 20, 2020 · Fundamentals

How to Create Effective Architecture Diagrams: Concepts, Types, and Best Practices

This article explains the value of technical diagramming, defines architecture and architecture diagrams, describes their purposes, outlines common diagram categories such as the 4+1 view, offers criteria for good diagrams, addresses typical pitfalls, and introduces the C4 model with concrete examples and a case study.

C4 ModelDiagramDocumentation
0 likes · 10 min read
How to Create Effective Architecture Diagrams: Concepts, Types, and Best Practices