BestHub
Sign in
Tagged articles

Software Design

439 articles · Page 3 of 5
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.

Cloud StorageCode ReviewSoftware Design
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.

Software Designbackendgolang
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 ProgrammingModulesPython
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.

DocumentationModelingSoftware Design
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
Alibaba Terminal Technology
Alibaba Terminal Technology
Jun 14, 2022 · Fundamentals

Why Code Comments Matter: Balancing Documentation and Clean Code

The article explores the purpose, controversy, and best practices of code comments, arguing that while excellent code can be self‑explanatory, thoughtful comments are essential for readability, maintenance, and conveying intent, especially in complex or ambiguous scenarios.

Software Designbest practicesclean code
0 likes · 21 min read
Why Code Comments Matter: Balancing Documentation and Clean Code
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.

Software Designabstractioncode quality
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 DesignHotel Transaction
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 theoremSOLIDSoftware Design
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 guidelinesService LayerSoftware Design
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.

Software Designarchitectural patternscode quality
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.

ComplexitySoftware Designarchitecture
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 DesignSoftware Engineeringbest practices
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.

Software Designcode qualitytesting
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 DesignSoftware Engineeringcode quality
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.

Domain ModelSequence DiagramSoftware Design
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.

Software Designarchitectural governancesoftware complexity
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.

Frontend ArchitectureSoftware Designdeveloper experience
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.

Software Designarchitectureprinciples
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.

MicroservicesSoftware Designbackend
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.

Software Designarchitecturebusiness identity
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.

Functional ProgrammingOpen-Closed PrincipleSoftware Design
0 likes · 18 min read
Unlock Front-End Power with Open-Closed, Functional Programming, and Messaging
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.

AggregationDatabaseModeling
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.

Code ArchitectureDAOModel
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.

C++Software DesignWeChat Pay
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.

DRYSoftware Designcode duplication
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-OrientedSoftware Designclean code
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.

Software Designclean codecode smells
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.

Communication SkillsIT ArchitectureSoftware Design
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.

PythonSOLIDSoftware Design
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.

Code ReviewSoftware Designarchitecture
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 modelSoftware Designarchitecture
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.

Software DesignWorse is Betterbackend-development
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 DesignMessage ArchitectureSoftware Design
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.

IDEASingle ResponsibilitySoftware Design
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.

AggregationAssociationSoftware Design
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 DesignSoftware Engineering
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.

Software Designabstractionclean code
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.

DDDDomain-Driven DesignSoftware 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
Java Interview Crash Guide
Java Interview Crash Guide
Aug 21, 2021 · Fundamentals

How to Create Clear Architecture Diagrams: A Practical C4‑Model Guide

This article explains why well‑crafted architecture diagrams are essential for technical communication, outlines common pitfalls, introduces the C4 modeling approach with its five views, and provides practical advice on drawing self‑describing diagrams that match audience needs and code reality.

C4 modelSoftware DesignSystem Modeling
0 likes · 11 min read
How to Create Clear Architecture Diagrams: A Practical C4‑Model Guide
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.

JavaScriptSoftware Designbest practices
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.

MicroservicesSoftware Designarchitecture
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.

Software Designbad practiceclean code
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.

Software DesignSystem Engineeringlarge-scale architecture
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.

Software DesignSystem Designbackend development
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.

Low-codeSoftware Designabstraction
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 modelingSoftware DesignUML
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 ArchitectureDevOpsSoftware Design
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.

ImplementationSoftware Designabstraction
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.

Software Designrefactoringrule engine
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.

DDDSoftware Designe-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.

Architecture DiagramModelingSoftware Design
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 modelSoftware DesignSystem Modeling
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.

Software DesignTypeScriptclean code
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.

PlantUMLRequirement AnalysisSequence 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.

Software Designinterfacesjava
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.

OOPSOLIDSoftware Design
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*Functional Programming
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.

MockingSoftware DesignTest 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 modelingNaming
0 likes · 24 min read
Why Mastering Abstraction Is the Secret to Cleaner, More Maintainable Code
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.

Functional ProgrammingHigher-Order FunctionsRxSwift
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.

AlibabaSoftware DesignTask System
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.

Software DesignWorkflow Engineapproval workflow
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.

Software Designarchitecture patternslayered 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.

POSIXSaaSSoftware Design
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.

DDDMicroservicesSoftware Design
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-OrientedProgramming FundamentalsSoftware Design
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.

Software Designcode readabilityself‑documenting code
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 systemSoftware Designmodularization
0 likes · 9 min read
Rethinking Layered Architecture: Lessons from Evolving the Coco System