BestHub
Sign in
Tagged articles

modularization

109 articles · Page 1 of 2
Java Captain
Java Captain
Sep 25, 2026 · Backend Development

Tencent Architect's Decade of Insights: Simple, Evolvable Architecture Principles

A Tencent architect with nearly ten years experience shares principles for simple, evolvable architecture: modularization, layering, focusing on core business needs like QQ's social chat, avoiding premature optimization, service design with monitoring and canary releases, and code design with clear structure and single responsibility.

QQSystem DesignTencent
0 likes · 4 min read
Tencent Architect's Decade of Insights: Simple, Evolvable Architecture Principles
Continuous Delivery 2.0
Continuous Delivery 2.0
Aug 21, 2026 · Fundamentals

AI Is Writing Code at Lightning Speed—Should We Still Enforce TDD? Classic Software Engineering Remains the Moat

The article argues that while AI can generate code rapidly, it amplifies bad code and technical debt, so solid fundamentals, architecture, and disciplined practices like TDD—applied judiciously—remain essential for maintainable software, with four typical AI coding failures and three practical collaboration models outlined.

AIDesignSoftware Engineering
0 likes · 7 min read
AI Is Writing Code at Lightning Speed—Should We Still Enforce TDD? Classic Software Engineering Remains the Moat
James' Growth Diary
James' Growth Diary
Jun 11, 2026 · Artificial Intelligence

Engineering AI Skills: When to Split, Tables, MCP vs HTTP, 5 Security Rules

The article outlines a practical engineering framework for AI Skills, detailing when to modularize based on line count and workflow separation, how to improve AI readability with tables and scripts, when to choose MCP servers versus simple HTTP calls, and five non‑negotiable security rules to keep Skills reliable and maintainable.

AI SkillsHTTPMCP
0 likes · 19 min read
Engineering AI Skills: When to Split, Tables, MCP vs HTTP, 5 Security Rules
Top Architect
Top Architect
Jun 10, 2026 · Backend Development

Why Spring Boot Plugin Development Is a Game‑Changer

This article explains how Spring Boot’s plugin architecture—using SPI, custom configuration, and Spring Factories—enables modular, extensible services, demonstrates step‑by‑step implementations with code samples, and shows real‑world use cases for building flexible micro‑service components.

Dependency InjectionJavaSPI
0 likes · 22 min read
Why Spring Boot Plugin Development Is a Game‑Changer
CodeNotes
CodeNotes
May 27, 2026 · Frontend Development

Mastering CSS Preprocessors: Practical Less and SCSS Guide (Part 4)

This article explains why CSS preprocessors are essential for large projects, demonstrates core features of Less and SCSS—including variables, nesting, mixins, inheritance, functions, and modularization—with real code examples, compares the two syntaxes, and offers recommendations and project‑structure guidelines for modern front‑end development.

CSScss-preprocessorfrontend
0 likes · 20 min read
Mastering CSS Preprocessors: Practical Less and SCSS Guide (Part 4)
Java Tech Workshop
Java Tech Workshop
May 21, 2026 · Fundamentals

Understanding Java's Module System: A Deep Dive into module-info.java

This article explains why Java modularization was introduced, outlines the problems with the pre‑Java 9 classpath, introduces the Java Platform Module System (JPMS) and its core file module-info.java, and provides detailed guidance on concepts, syntax, best practices, real‑world examples, IDE setup, and common pitfalls.

JPMSJavaModule System
0 likes · 43 min read
Understanding Java's Module System: A Deep Dive into module-info.java
Machine Heart
Machine Heart
Apr 30, 2026 · Artificial Intelligence

From Post‑hoc to Intrinsic: Cutting‑Edge Advances in Making Large Language Models More Transparent

This article surveys recent progress in intrinsic interpretability for large language models, contrasting traditional post‑hoc analysis with design‑level approaches that embed transparency into model architecture, training objectives, and information flow, and outlines five core design paradigms and their challenges.

intrinsic interpretabilitylarge language modelsmodel design principles
0 likes · 11 min read
From Post‑hoc to Intrinsic: Cutting‑Edge Advances in Making Large Language Models More Transparent
Data STUDIO
Data STUDIO
Feb 26, 2026 · Fundamentals

Stop Using a Monolithic utils.py: 3 Design Patterns to Make Your Python Code Cleaner

The article explains why a sprawling utils.py becomes a maintenance nightmare in Python projects, outlines three concrete patterns—module‑level placement, class‑based methods, and small dedicated modules—to restructure code, and provides decision criteria for when a function truly belongs in a utility module.

Design Patternscode organizationmodularization
0 likes · 11 min read
Stop Using a Monolithic utils.py: 3 Design Patterns to Make Your Python Code Cleaner
Architect
Architect
Oct 31, 2025 · Backend Development

Why Spring Boot 4’s Modular Architecture Boosts Performance and Maintainability

Spring Boot 4 introduces a modular architecture that splits the monolithic auto‑configuration package into focused modules, reducing size, speeding startup, improving memory usage, and offering clearer dependencies, while providing dedicated test starters and a classic starter for smooth migration from Spring Boot 3.

JavaSpring Bootbackend development
0 likes · 7 min read
Why Spring Boot 4’s Modular Architecture Boosts Performance and Maintainability
Su San Talks Tech
Su San Talks Tech
Oct 29, 2025 · Backend Development

Why Spring Boot 4’s Modular Architecture Makes Your Apps Faster and Lighter

Spring Boot 4 introduces a modular architecture that splits the monolithic auto‑configuration package into focused modules, reducing size and startup time, improving maintainability, and offering precise dependency control, while providing new testing starters and a classic‑starter migration path for existing projects.

JavaSpring Bootmigration
0 likes · 7 min read
Why Spring Boot 4’s Modular Architecture Makes Your Apps Faster and Lighter
Java Architect Essentials
Java Architect Essentials
Sep 10, 2025 · Backend Development

How to Tame Java Dependency Hell with Modular Design

This article explains the common pain points of Java package management—naming conflicts, circular dependencies, and version chaos—and shows how modular design using JPMS, strict Maven rules, and tooling can dramatically reduce conflicts, build time, and improve code maintainability.

JPMSJavabackend development
0 likes · 6 min read
How to Tame Java Dependency Hell with Modular Design
Java Architect Essentials
Java Architect Essentials
Jul 4, 2025 · Backend Development

Avoid Dependency Nightmares: Best Practices for Building Reusable Spring Boot Starters

The article shares real‑world experiences and step‑by‑step guidelines for creating robust, modular Spring Boot starters—especially for logging and monitoring—covering dependency conflict detection, strict dependency scopes, SPI design, configuration conventions, documentation standards to dramatically improve reuse and reduce integration headaches.

Custom StarterSpring Bootdependency management
0 likes · 11 min read
Avoid Dependency Nightmares: Best Practices for Building Reusable Spring Boot Starters
Test Development Learning Exchange
Test Development Learning Exchange
Mar 4, 2025 · Fundamentals

Understanding Python Modularization and Import Mechanisms

This article explains the fundamentals of Python modularization, covering basic concepts, various import styles, practical use‑case examples, and best‑practice guidelines such as avoiding circular dependencies and using clear package structures to improve code maintainability and scalability.

code organizationimportmodularization
0 likes · 7 min read
Understanding Python Modularization and Import Mechanisms
JavaScript
JavaScript
Feb 10, 2025 · Frontend Development

8 Essential Modularization Techniques to Master Large Frontend Projects

This article presents eight practical modularization strategies—including ES Modules, componentization, separation of concerns, conventions, bundlers, dependency injection, lazy loading, and versioning—to help developers transform sprawling frontend codebases into clean, reusable, and maintainable systems.

Component ArchitectureDependency InjectionES Modules
0 likes · 8 min read
8 Essential Modularization Techniques to Master Large Frontend Projects
Java Architect Essentials
Java Architect Essentials
Jan 6, 2025 · Backend Development

Using @Import for Modular Spring Boot Applications

This article explains how to modularize a Spring Boot monolith by splitting it into Maven modules, leveraging @ComponentScan, @Import, custom annotations, ImportSelector, ImportBeanDefinitionRegistrar, and conditional loading to dynamically include or exclude functionality at runtime.

ComponentScanConfigurationMaven
0 likes · 18 min read
Using @Import for Modular Spring Boot Applications
DevOps
DevOps
Sep 19, 2024 · Fundamentals

Understanding Software Architecture: Concepts, Layers, and Design Principles

This article explains the fundamentals of software architecture, covering its definition, key components such as systems, modules, components, and subsystems, and explores vertical (layered) and horizontal (modular) architectures, design principles, complexity evaluation, cross‑platform considerations, and practical guidelines for building maintainable applications.

App Developmentcomplexity managementdesign principles
0 likes · 10 min read
Understanding Software Architecture: Concepts, Layers, and Design Principles
Architect
Architect
Sep 3, 2024 · Frontend Development

Designing a Reusable, Flexible, and Stable Detail Page Framework

This article analyzes the challenges of maintaining high‑traffic detail pages across multiple business teams and proposes a three‑layer, dependency‑injection‑enabled framework that ensures reusability, flexibility, and stability while supporting fast onboarding and robust quality assurance.

Dependency Injectionfrontendmodularization
0 likes · 10 min read
Designing a Reusable, Flexible, and Stable Detail Page Framework
DaTaobao Tech
DaTaobao Tech
Jul 5, 2024 · Backend Development

Introduction to the Java Module System (Project Jigsaw)

The Java Module System (Project Jigsaw) introduced in Java 9 defines uniquely named modules with descriptors that declare dependencies, exported and opened packages, and services, enabling clear dependency management, smaller custom runtimes, stronger encapsulation, improved performance, security, and easier maintenance, while supporting migration strategies and best‑practice guidelines.

JDKJavaModule System
0 likes · 21 min read
Introduction to the Java Module System (Project Jigsaw)
Watermelon Video Tech Team
Watermelon Video Tech Team
Dec 12, 2023 · Mobile Development

A Guide to the Architecture Design Process for Mobile Applications

This article outlines a systematic approach to mobile architecture design, covering goals, when to create new architectures, requirement analysis, business flow mapping, pattern discovery, layering, modularization, lifecycle interfaces, verification, and evolution, illustrated with a Feed scenario and code examples.

Design PatternsSoftware Engineeringarchitecture
0 likes · 19 min read
A Guide to the Architecture Design Process for Mobile Applications
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 7, 2023 · Mobile Development

Comprehensive Guide to Building Modern Android Apps in 2023

This article provides a detailed overview of the latest 2023 trends, tools, libraries, architectural patterns, and best practices for developing modern Android applications, covering everything from Kotlin and Jetpack Compose to Clean Architecture, modularization, performance optimization, and Google Play features.

AndroidDependency InjectionJetpack Compose
0 likes · 16 min read
Comprehensive Guide to Building Modern Android Apps in 2023
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 29, 2023 · Frontend Development

Understanding Front-End Engineering: From Module Systems to npm and webpack

This article explains front‑end engineering, tracing its evolution from simple page building to modern modular architectures, and details how tools like npm, CommonJS, AMD, CMD, ESModules and webpack address challenges such as scope pollution, code standards, resource optimization, testing, CI/CD, and team collaboration.

Module Systemengineeringfrontend
0 likes · 17 min read
Understanding Front-End Engineering: From Module Systems to npm and webpack
Tencent Cloud Developer
Tencent Cloud Developer
Oct 11, 2023 · Frontend Development

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

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

Domain-Driven Designarchitecture patternsclean architecture
0 likes · 21 min read
Clean Architecture in Front-End Development: Principles, Practices, and Comparative Analysis
ByteFE
ByteFE
Aug 16, 2023 · Frontend Development

Evolution of Frontend Module Systems and Major Module Specifications

This article traces the history of frontend modularization from early global‑function scripts through IIFE, CommonJS, ES6 modules, AMD and CMD, explaining why modularization is needed, how each approach works, their drawbacks, and the key features of each specification.

AMDCommonJScmd
0 likes · 14 min read
Evolution of Frontend Module Systems and Major Module Specifications
JD Cloud Developers
JD Cloud Developers
Jul 18, 2023 · Mobile Development

Why Componentization Is Essential for Scalable Mobile Apps

This article explores the motivations, benefits, challenges, and practical guidelines for adopting a component‑based architecture in medium‑to‑large mobile applications, covering topics such as modular granularity, dependency management, communication patterns, version compatibility, quality assurance, and the trade‑offs of componentization versus monolithic projects.

CI quality checksComponentizationdependency management
0 likes · 31 min read
Why Componentization Is Essential for Scalable Mobile Apps
Programmer DD
Programmer DD
Dec 26, 2022 · Fundamentals

20 Essential Software Architecture Principles Every Engineer Should Master

This article presents a concise overview of twenty core software architecture principles—from Dependency Inversion and Separation of Concerns to KISS and Incremental Development—explaining each concept, its purpose, and providing Java code examples to illustrate practical application.

EncapsulationSOLIDdesign principles
0 likes · 12 min read
20 Essential Software Architecture Principles Every Engineer Should Master
Huolala Tech
Huolala Tech
Nov 30, 2022 · Mobile Development

How TheRouter Simplifies Android Modular Routing with APT and ASM

This article explains why a routing framework is essential for Android apps, analyzes TheRouter's source code, and shows how it uses annotation processing and ASM bytecode injection to handle page navigation, parameter injection, and cross‑module method calls in a modular architecture.

ASMAndroidDependencyInjection
0 likes · 27 min read
How TheRouter Simplifies Android Modular Routing with APT and ASM
Sohu Tech Products
Sohu Tech Products
Nov 17, 2022 · Mobile Development

Exploring iOS Componentization

This article introduces iOS componentization using CocoaPods, detailing the drawbacks of manual code copying, explaining the creation of local podspec libraries, configuring source files, resources, access levels, and integration steps, while also covering sub‑specs, resource bundles, and practical code examples for Swift projects.

CocoaPodsComponentizationSwift
0 likes · 26 min read
Exploring iOS Componentization
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 11, 2022 · Mobile Development

Advanced Android Componentization: Component Splitting, Multi‑UI Strategies, KV Storage, and Routing Best Practices

This article explains how to split Android components based on business functionality, handle strong and weak component dependencies, configure multiple UI themes, manage key‑value storage safely with MMKV‑KTX, and use routing frameworks judiciously to keep modular apps maintainable and scalable.

AndroidComponentizationKV storage
0 likes · 22 min read
Advanced Android Componentization: Component Splitting, Multi‑UI Strategies, KV Storage, and Routing Best Practices
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 11, 2022 · Mobile Development

Practical Guide to Android Componentization and Modular Development

This article explains why monolithic Android projects suffer from long compile times, high coupling, and merge conflicts, and demonstrates how componentization—using a four‑layer architecture, unified Gradle dependencies, plugin switching, code isolation, ARouter routing, decentralized APIs, and AndroidX App Startup initialization—can solve these problems with concrete Kotlin and XML examples.

ARouterAndroidComponentization
0 likes · 21 min read
Practical Guide to Android Componentization and Modular Development
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
Sep 19, 2022 · Mobile Development

NetEase Yanxuan iOS App Architecture Evolution: A Case Study in Modularization and Engineering Optimization

The article details how NetEase Yanxuan’s massive iOS codebase was refactored through modularization and layered architecture—splitting the main project, isolating business modules, automating dependency analysis, binaryizing core libraries, and cleaning unused resources—resulting in reduced coupling, a 6% faster compile time, and a sustainable CI‑driven development workflow.

App Architecture EvolutionCI/CDCode Decoupling
0 likes · 18 min read
NetEase Yanxuan iOS App Architecture Evolution: A Case Study in Modularization and Engineering Optimization
Huolala Tech
Huolala Tech
Sep 6, 2022 · Mobile Development

Master Android Modular Routing with TheRouter: Features, Usage, and Migration

TheRouter is a Kotlin‑based, full‑stack solution for Android modular development that provides page navigation, cross‑module dependency injection, automatic initialization, dynamic actions, and remote route table updates, offering extensive configuration, code‑free reflection, and tools for migration, debugging, and performance optimization.

AndroidDependencyInjectionDynamicRouting
0 likes · 20 min read
Master Android Modular Routing with TheRouter: Features, Usage, and Migration
Xianyu Technology
Xianyu Technology
Feb 10, 2022 · Mobile Development

Design and Implementation of an Android Chain Framework for Business Decoupling

The Android Chain framework decouples business modules by turning call points into annotated extension points, generating interface‑to‑implementation mappings at compile time, merging them via a Gradle plugin, and exposing them through a runtime singleton that supports priority, dynamic proxies, custom URL protocols, and ProGuard‑safe automatic registration.

AndroidAnnotationProcessingDependencyInjection
0 likes · 8 min read
Design and Implementation of an Android Chain Framework for Business Decoupling
Sohu Tech Products
Sohu Tech Products
Nov 24, 2021 · Frontend Development

Modularization Practices in Vivo Game Center: Componentization, Configuration, and Experimentation

This article explains how Vivo Game Center adopted a modular architecture—combining componentization, configuration, and experiment-driven deployment—to enable rapid, flexible UI layout adjustments, unified backend processes, and data-driven A/B testing, thereby improving development efficiency and user‑targeted operations.

AB TestingBackendMobile App
0 likes · 17 min read
Modularization Practices in Vivo Game Center: Componentization, Configuration, and Experimentation
IT Architects Alliance
IT Architects Alliance
Nov 14, 2021 · Mobile Development

How Microapps Revolutionize Mobile Development Speed and Flexibility

The article examines the microapp architecture pattern—derived from microservices—to modularize mobile codebases, accelerate build and test cycles, and improve team autonomy, while also discussing its foundations, challenges, trade‑offs, and practical adoption steps.

CI/CDMobile Developmentarchitecture
0 likes · 12 min read
How Microapps Revolutionize Mobile Development Speed and Flexibility
vivo Internet Technology
vivo Internet Technology
Nov 10, 2021 · Game Development

Modularization Practices in Vivo Game Center: Componentization, Configuration, and Experimentation

To meet rapid growth and diverse user needs, Vivo’s Game Center adopted a modular architecture that separates visual templates from data, enabling reusable UI components, configurable page assembly, and AB‑test driven experimentation, which together cut release cycles, streamline backend workflows, and boost scalability and developer productivity.

AB TestingComponent-Based Architecturebackend configuration
0 likes · 17 min read
Modularization Practices in Vivo Game Center: Componentization, Configuration, and Experimentation
TikTok Frontend Technology Team
TikTok Frontend Technology Team
Oct 9, 2021 · Frontend Development

Frontend Engineering Practices: Componentization, Modularization, and Build Optimization

The article outlines the Douyin front‑end team's engineering philosophy, covering the need for modularization of HTML, CSS, and JavaScript, component systems, dependency handling, build tools, loaders, and performance‑focused tooling to improve development efficiency and browser runtime speed.

ComponentizationPerformancebuild
0 likes · 9 min read
Frontend Engineering Practices: Componentization, Modularization, and Build Optimization
Alibaba Terminal Technology
Alibaba Terminal Technology
Sep 17, 2021 · Mobile Development

Taming iOS Architecture Decay: Strategies to Boost Build Efficiency

An in‑depth case study of Alibaba.com’s iOS client reveals how architectural decay—manifested as tangled module dependencies, slow builds, and outdated tooling—drains developer productivity, and outlines data‑driven, layered, and automated strategies—including dependency analysis, modular refactoring, and CI safeguards—to restore a healthy, scalable mobile codebase.

Build Optimizationarchitecturedependency analysis
0 likes · 17 min read
Taming iOS Architecture Decay: Strategies to Boost Build Efficiency
JD Retail Technology
JD Retail Technology
Aug 16, 2021 · Backend Development

Refactoring a Complex Backend System: Decoupling Logic, Dynamic Configuration, and Result Isolation

This article shares practical refactoring techniques applied to JD App's backend, demonstrating how to decouple tightly‑coupled modules, replace hard‑coded logic with dynamic configuration, and isolate result fields to improve maintainability and extensibility in large‑scale backend projects.

dynamic-configurationmodularizationrefactoring
0 likes · 11 min read
Refactoring a Complex Backend System: Decoupling Logic, Dynamic Configuration, and Result Isolation
NetEase Media Technology Team
NetEase Media Technology Team
Jul 21, 2021 · Mobile Development

Componentization Practices in NetEase News iOS Application

The NetEase News iOS team adopted a three‑layer componentization strategy—foundation, common, and business—standardizing code conventions, Git workflow, and CI‑driven reviews, encapsulating third‑party libraries, managing dependencies via injection and mediators, and distributing binary pods, which reduced the main project to a single file while expanding reusable components to over 250, achieving low coupling and high cohesion.

Component Architecturedependency managementiOS
0 likes · 19 min read
Componentization Practices in NetEase News iOS Application
IT Architects Alliance
IT Architects Alliance
Jul 4, 2021 · Industry Insights

Why Do Software Architectures Decay Over Time and How to Prevent It?

The article examines why software architectures inevitably degrade as projects grow, outlines the stages of decay, critiques common quick fixes, and proposes strategic solutions such as adopting new technologies, refactoring into isolated components, using separate processes, and building loosely coupled platforms to sustain long‑term maintainability.

Build OptimizationPlatform Designcode decay
0 likes · 25 min read
Why Do Software Architectures Decay Over Time and How to Prevent It?
IT Architects Alliance
IT Architects Alliance
Apr 25, 2021 · Frontend Development

How Baidu Revamped Its Search Front‑End Architecture: Lessons for Modern Web Development

This article analyses the evolution of Baidu's search result page front‑end architecture, identifies scalability, coupling, and technology‑stack problems, and presents a three‑layer strategy—foundation, modular middle layer, and componentized top layer—along with concrete implementation steps such as TypeScript adoption, service‑oriented modules, dependency‑injection containers, and SSR performance optimizations.

ComponentizationPerformanceSSR
0 likes · 14 min read
How Baidu Revamped Its Search Front‑End Architecture: Lessons for Modern Web Development
IT Architects Alliance
IT Architects Alliance
Apr 3, 2021 · Frontend Development

How Baidu Re‑engineered Its Mobile Search Front‑End Architecture for Scale

This article analyzes Baidu's mobile search front‑end architecture evolution, identifying scalability and maintainability challenges, outlining a three‑layer redesign strategy, and detailing concrete modularization, componentization, and SSR techniques that other large‑scale web teams can apply.

BaiduComponentizationDependency Injection
0 likes · 14 min read
How Baidu Re‑engineered Its Mobile Search Front‑End Architecture for Scale
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 3, 2021 · Frontend Development

How Baidu Redesigned Its Mobile Search Front‑End Architecture for Scale and Performance

This article examines Baidu's mobile search front‑end architecture, identifies scalability and maintainability challenges such as massive codebases, unclear responsibilities, tight coupling and outdated tech stacks, and explains the three‑layer solution—foundation, modular middle layer, and componentization—along with implementation details, dependency injection, SSR adoption, and performance optimizations.

BaiduComponentizationDependency Injection
0 likes · 14 min read
How Baidu Redesigned Its Mobile Search Front‑End Architecture for Scale and Performance
Architecture Digest
Architecture Digest
Mar 28, 2021 · Frontend Development

Frontend Architecture Evolution: Lessons from Baidu Search Result Page

The article examines the evolution of front‑end architecture using Baidu's mobile search result page as a case study, outlining challenges such as massive codebases, coupling, and outdated tech stacks, and presenting a three‑layer solution involving foundation, modularization, and componentization with SSR optimization.

BaiduComponentizationPerformance
0 likes · 13 min read
Frontend Architecture Evolution: Lessons from Baidu Search Result Page
21CTO
21CTO
Mar 25, 2021 · Frontend Development

How Baidu Revamped Its Mobile Search Front‑End Architecture for Scale and Performance

This article examines Baidu's mobile search front‑end architecture evolution, detailing the challenges of massive codebases, unclear responsibilities, and outdated tech stacks, and explains how a three‑layer modular design, dependency‑injection container, componentization with San, and optimized server‑side rendering were employed to improve scalability, maintainability, and page performance.

BaiduComponentizationFrontend Architecture
0 likes · 14 min read
How Baidu Revamped Its Mobile Search Front‑End Architecture for Scale and Performance
Architect
Architect
Mar 25, 2021 · Frontend Development

Front‑end Architecture Design: Lessons from Baidu Search Result Page

This article examines the evolution and challenges of large‑scale front‑end architecture, using Baidu's search result page as a case study to illustrate problems such as massive codebases, unclear responsibilities, and outdated tech stacks, and describes a three‑layer modular, component‑based solution with SSR and DI to improve maintainability and performance.

BaiduComponentizationSSR
0 likes · 13 min read
Front‑end Architecture Design: Lessons from Baidu Search Result Page
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.

modularizationplugin systemsoftware design
0 likes · 9 min read
Rethinking Layered Architecture: Lessons from Evolving the Coco System
Sohu Tech Products
Sohu Tech Products
Jan 28, 2021 · Mobile Development

Android Componentization: Architecture, Independent Debugging, Routing, and Communication

This article explains how to transform a large Android project into a componentized architecture by modularizing code, configuring Gradle for independent debugging, using ARouter for page navigation and service communication, handling fragment instances, distributing Application lifecycle events, and migrating legacy projects.

ARouterComponentizationDependencyInjection
0 likes · 32 min read
Android Componentization: Architecture, Independent Debugging, Routing, and Communication
Xianyu Technology
Xianyu Technology
Sep 3, 2020 · Mobile Development

Modularization and Cross‑Process Communication Strategies for Xianyu's Flutter Application

Xianyu tackles Flutter’s slow hybrid compilation and native‑module integration pain by introducing a minimal‑shell modular architecture and a two‑phone cross‑process setup that falls back from MethodChannel to socket communication, speeding builds, isolating components, and improving data consistency while adding maintenance and device constraints.

AndroidCross-ProcessFlutter
0 likes · 9 min read
Modularization and Cross‑Process Communication Strategies for Xianyu's Flutter Application
Xianyu Technology
Xianyu Technology
Apr 3, 2020 · Mobile Development

Evolution of Xianyu's Flutter Architecture and Mobile Development Journey

Facing performance and stability limits of native and Weex, Alibaba’s Xianyu migrated to Flutter through a three‑year research, validation and rollout process, building a Spring‑IoC‑style modular architecture, the Flutter_Boost hybrid stack, and extended engine features that doubled development speed, achieved 80 % code sharing, and outperformed native apps on low‑end phones, while paving the way for the Alibaba‑wide AliFlutter initiative.

FlutterMobile DevelopmentPerformance
0 likes · 15 min read
Evolution of Xianyu's Flutter Architecture and Mobile Development Journey
Top Architect
Top Architect
Mar 25, 2020 · Fundamentals

Architecture Corruption: Causes, Stages, and Mitigation Strategies

Long‑running software projects inevitably see their initially clean architectures degrade as codebases grow, teams expand, and build times increase, but by understanding the stages of architectural decay and applying practices such as modular isolation, incremental builds, tooling upgrades, and disciplined refactoring, teams can slow or reverse this corrosion.

Build Optimizationmodularizationrefactoring
0 likes · 23 min read
Architecture Corruption: Causes, Stages, and Mitigation Strategies
Youzan Coder
Youzan Coder
Mar 4, 2020 · Mobile Development

Unified Online Store Product SDK: Architecture, Modularization, and Mobile Gateway Integration

The unified online‑store product SDK consolidates Retail and Micro‑Mall modules into a reusable, Bifrost‑mediated component that accesses host‑app data via a defined interface, adopts standardized UI elements, routes through a mobile‑gateway backend, and thus eliminates duplication, streamlines maintenance, and accelerates feature delivery across Youzan’s SaaS platforms.

AndroidSDKe-commerce
0 likes · 14 min read
Unified Online Store Product SDK: Architecture, Modularization, and Mobile Gateway Integration
Meituan Technology Team
Meituan Technology Team
Feb 27, 2020 · Frontend Development

Micro‑Frontend Implementation in Meituan Waimai Advertising Platform

Meituan Waimai’s advertising team tackled duplicated business logic and slow builds across PC, H5, and KA by merging code into a monorepo and adopting a React‑based central‑router micro‑frontend architecture, where a host app dynamically loads sub‑apps with independent routing, stores, CSS, and hot‑module replacement, achieving modularization, faster builds, and isolated deployment.

Frontend ArchitectureHot ReloadReAct
0 likes · 24 min read
Micro‑Frontend Implementation in Meituan Waimai Advertising Platform
58 Tech
58 Tech
Dec 30, 2019 · Mobile Development

Platformization and Architecture Refactoring of the Anjuke Android App: Challenges, Solutions, and Lessons Learned

This article details the Anjuke Android app’s transition to a platform-based architecture, describing the background, challenges of scaling and cross‑team collaboration, the design of a unified middle layer, hybrid SDK, dynamic routing, gray‑release strategies, and the insights gained from the extensive refactoring effort.

AndroidGray ReleaseHybrid SDK
0 likes · 18 min read
Platformization and Architecture Refactoring of the Anjuke Android App: Challenges, Solutions, and Lessons Learned
Yanxuan Tech Team
Yanxuan Tech Team
Dec 23, 2019 · Frontend Development

How NetEase Yanxuan Scales Front‑End Development with Enterprise‑Grade Micro‑Frontend Architecture

This article details NetEase Yanxuan's enterprise micro‑frontend solution, covering its architectural design, isolation techniques, communication mechanisms, configuration center, and the concrete business benefits such as breaking down giant monoliths, improving module reuse, and streamlining multi‑team collaboration.

JavaScriptapplication isolationenterprise
0 likes · 23 min read
How NetEase Yanxuan Scales Front‑End Development with Enterprise‑Grade Micro‑Frontend Architecture
Alibaba International Technology
Alibaba International Technology
Dec 20, 2019 · Mobile Development

Mastering Mobile Architecture: Boost Efficiency with Wireless App Design

This article shares an Alibaba engineer’s comprehensive insights on wireless (mobile) architecture, covering stakeholder analysis, engineering structure, code coupling, component reuse, technology decisions, performance comparison of Flutter and Weex, tooling, stability, leadership, organization, modularization, and future expansion to help developers improve efficiency and product quality.

Androidarchitecturedevelopment
0 likes · 31 min read
Mastering Mobile Architecture: Boost Efficiency with Wireless App Design
Product Technology Team
Product Technology Team
Dec 18, 2019 · Mobile Development

Mastering Android Componentization: A Practical Guide to Modular Mobile Apps

This article explains why Android projects adopt componentization, outlines its goals, presents a three‑layer architecture, and provides step‑by‑step instructions for creating modules, managing Gradle settings, handling manifests, routing, event buses, and enabling independent module execution to improve maintainability and development efficiency.

ARouterAndroidEventBus
0 likes · 18 min read
Mastering Android Componentization: A Practical Guide to Modular Mobile Apps
Tencent Cloud Developer
Tencent Cloud Developer
Sep 6, 2019 · Frontend Development

Exploration and Practice of Frontend Engineering

The article examines modern frontend engineering by detailing its four‑stage lifecycle—development, testing, deployment, maintenance—and reviewing modularization of JavaScript and CSS, component‑based frameworks and Web Components, code and workflow standardization, automation tools, and a real‑world migration to ES6 modules, Rollup, CSS Modules, Jest, and CI pipelines.

Build ToolsCI/CDCSS Modules
0 likes · 40 min read
Exploration and Practice of Frontend Engineering
Baidu App Technology
Baidu App Technology
Jul 8, 2019 · R&D Management

Scaling Parallel Development: Baidu App’s Journey to Component‑Based Architecture

Facing massive codebases, hundreds of developers, and rapid release cycles, Baidu App adopted a multi‑stage componentization strategy—spanning compile isolation, library standardization, runtime distribution, service layers, and degradation control—to improve parallel development, reduce complexity, and boost build speed and quality.

Build OptimizationComponentizationParallel Development
0 likes · 18 min read
Scaling Parallel Development: Baidu App’s Journey to Component‑Based Architecture
Seewo Tech Circle
Seewo Tech Circle
Jun 25, 2019 · Mobile Development

From Monolithic Android App to Modular Architecture: Lessons and Strategies

This article recounts the evolution of the Class Optimization Master Android project—from a dual‑end, no‑design prototype to an MVP‑based implementation and finally a modularized architecture—highlighting pain points, solutions, and practical steps for improving code boundaries, build times, and reusable modules.

AndroidMVPPerformance
0 likes · 12 min read
From Monolithic Android App to Modular Architecture: Lessons and Strategies
Architecture Digest
Architecture Digest
Jun 23, 2019 · Mobile Development

Componentized Architecture for iOS Projects: Analysis of MGJRouter, Protocol, and CTMediator

This article examines the motivations, design patterns, and practical implementations of componentized architectures in iOS development, comparing MGJRouter, Protocol‑based routing, and CTMediator solutions, and provides guidelines for integration, memory management, and dynamic configuration in large‑scale mobile applications.

CTMediatorComponent ArchitectureMGJRouter
0 likes · 42 min read
Componentized Architecture for iOS Projects: Analysis of MGJRouter, Protocol, and CTMediator
Youzan Coder
Youzan Coder
Apr 23, 2019 · Mobile Development

Modular Architecture and Componentization for Youzan Android Applications

Youzan refactored its Android Micro Mall and Retail apps from a monolithic codebase into a service‑oriented, componentized architecture where each business module inherits a BaseModule with its own lifecycle, common utilities are extracted into lightweight libraries, and a custom Gradle plugin enables independent building, publishing, and rapid iteration.

AndroidGradlemodularization
0 likes · 25 min read
Modular Architecture and Componentization for Youzan Android Applications
Beike Product & Technology
Beike Product & Technology
Nov 30, 2018 · Mobile Development

Refactoring a 2000‑Line Android Detail Page to Under 200 Lines Using MVP and Modularization

This article describes how a large, tightly‑coupled Android detail page was refactored into a clean, modular MVP architecture that splits business logic into reusable Parts, reducing the file size from over 2000 lines to fewer than 200 while improving readability, maintainability, and rendering performance.

AndroidMVPMobile Development
0 likes · 18 min read
Refactoring a 2000‑Line Android Detail Page to Under 200 Lines Using MVP and Modularization
Sohu Tech Products
Sohu Tech Products
Oct 31, 2018 · Mobile Development

Componentization Architecture for iOS Mobile Applications

This article presents a comprehensive component‑based architecture for iOS navigation apps, detailing layered design, responsibility division, integration methods, MGJRouter communication, H5‑Native interaction, dynamic configuration, and insights from Taobao's large‑scale componentization practice.

CocoaPodsMGJRouterdynamic-configuration
0 likes · 18 min read
Componentization Architecture for iOS Mobile Applications
Meituan Technology Team
Meituan Technology Team
Sep 20, 2018 · Mobile Development

Platformized Code Reuse in Meituan Waimai Android: Challenges and Solutions

Meituan Waimai Android unified the divergent codebases of the standalone Waimai app and the Waimai channel in the Meituan app by introducing a layered architecture—base services, components, business modules, and host—combined with Gradle flavor and a fine‑grained “pins” project, achieving 88 % code reuse, over 70 % productivity improvement, and paving the way for broader platform reuse.

AndroidMobile DevelopmentPlatform Architecture
0 likes · 17 min read
Platformized Code Reuse in Meituan Waimai Android: Challenges and Solutions
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 1, 2018 · Fundamentals

Why Componentization and Modularity Are Key to Microservice Success

This article explains core microservice concepts—including componentization, modularization, centralized vs. distributed systems, and the architectural principles behind microservices—while comparing them to SOA and highlighting practical distinctions that help developers design loosely‑coupled, reusable services.

Componentizationdistributed systemsmicroservices
0 likes · 8 min read
Why Componentization and Modularity Are Key to Microservice Success
iQIYI Technical Product Team
iQIYI Technical Product Team
Jun 15, 2018 · Mobile Development

iQIYI Technical Salon Shanghai – Mobile Componentization and Webization Practices

At the iQIYI Technical Salon in Shanghai, senior engineers from iQIYI, Ele.me, Mushroom Street and others shared practical advances in mobile componentization and webization, including Ele.me’s hierarchical Android modularization, the open‑source CC framework, iQIYI’s Qigsaw dynamic delivery and Utopia web‑SPA, LiteApp performance optimizations, and the Lynx cross‑platform framework, while inviting developers to join iQIYI’s R&D team.

AndroidComponentizationMobile Development
0 likes · 7 min read
iQIYI Technical Salon Shanghai – Mobile Componentization and Webization Practices
21CTO
21CTO
May 12, 2018 · Mobile Development

Why Mobile App Architecture Matters: Lessons from Real-World Projects

This article explores the concept of software architecture for mobile apps, sharing personal reflections, industry case studies, design principles, modularization strategies, development practices, testing, risk management, and agile processes to help developers build maintainable, scalable, and high‑quality applications.

AgileAndroid developmentmobile architecture
0 likes · 47 min read
Why Mobile App Architecture Matters: Lessons from Real-World Projects
Ctrip Technology
Ctrip Technology
May 9, 2018 · Mobile Development

Modular Refactoring and Decoupling Strategies for Large‑Scale Android Applications

This article explains how to apply modular refactoring—removing unnecessary files, reorganizing packages, degrading monolithic classes, and decoupling components—using tools such as IronBank, BizLifecycle, and AAR‑based platform support to achieve zero‑coupling, easier version management, and faster builds in Android projects.

AARAndroidCode Decoupling
0 likes · 13 min read
Modular Refactoring and Decoupling Strategies for Large‑Scale Android Applications
Suning Technology
Suning Technology
Apr 18, 2018 · Mobile Development

How Suning’s Android App Evolved: Architecture Lessons Across Three Mobile Eras

This article reviews the evolution of Suning's e‑commerce Android client from 2012 to the present, detailing the technical challenges of each development stage, the corresponding architectural solutions, and the lessons learned for building high‑performance, modular mobile applications.

AndroidApp DevelopmentPerformance Optimization
0 likes · 11 min read
How Suning’s Android App Evolved: Architecture Lessons Across Three Mobile Eras
ITPUB
ITPUB
Mar 30, 2018 · Fundamentals

5 Simple Principles for Writing Clean, Maintainable Code

The article presents five practical concepts—avoiding overly clever tricks, modularizing with divide‑and‑conquer, keeping code IDE‑friendly, ensuring readability through clear architecture and naming, and minimizing branching—to help developers write clean, maintainable code and boost productivity.

clean codecode qualitymodularization
0 likes · 9 min read
5 Simple Principles for Writing Clean, Maintainable Code
Meituan Technology Team
Meituan Technology Team
Mar 15, 2018 · Mobile Development

Platformization and Code Reuse Practices in Meituan Waimai Android Client

Facing duplicated codebases as Meituan Waimai expanded from a single app to multiple channels, the team iteratively tried split libraries, componentization, and MVP layers before settling on a three‑layer platform architecture—platform, business, and host—isolated via Gradle projects, product flavors, and tooling to achieve sustainable, cross‑product code reuse.

AndroidGradlecode reuse
0 likes · 25 min read
Platformization and Code Reuse Practices in Meituan Waimai Android Client
Qunar Tech Salon
Qunar Tech Salon
Nov 2, 2017 · Frontend Development

Meituan's Hermes Project: Front‑End Architecture, Modularization, Automation, and Performance Optimization

Meituan's Hermes project demonstrates how a large‑scale front‑end team achieved better developer experience and maintainability by adopting front‑back separation, ES6‑based modular and Vue component architecture, automated build pipelines, local mock services, comprehensive monitoring, network and offline optimizations, and outlines future plans for server‑side rendering and service‑worker migration.

ComponentizationPerformancemodularization
0 likes · 14 min read
Meituan's Hermes Project: Front‑End Architecture, Modularization, Automation, and Performance Optimization
Meituan Technology Team
Meituan Technology Team
Oct 30, 2017 · Frontend Development

Hermes Project: Front‑End Architecture, Modularization, Componentization, Automation and Performance Optimization at Meituan‑Dianping

The Hermes project at Meituan‑Dianping re‑engineered its overseas vacation front‑end by separating front‑ and back‑ends, modularizing code with ES6, building a Vue‑based reusable component library, automating builds and testing, and optimizing page‑load performance through CDN caching, monitoring, and offline strategies, dramatically boosting developer productivity and user experience.

ComponentizationMeituanPerformance Optimization
0 likes · 15 min read
Hermes Project: Front‑End Architecture, Modularization, Componentization, Automation and Performance Optimization at Meituan‑Dianping
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 31, 2017 · Frontend Development

From Frameworks to Smart Resource Management: Evolving Frontend Engineering

This article examines the evolution of frontend development from basic library selection through simple build optimization, modularization, and finally to component‑based development and intelligent static resource management, highlighting engineering practices that improve efficiency, scalability, and performance for complex web applications.

ComponentizationWeb Performanceengineering
0 likes · 21 min read
From Frameworks to Smart Resource Management: Evolving Frontend Engineering
WeChat Client Technology Team
WeChat Client Technology Team
Jun 30, 2017 · Mobile Development

How WeChat Re‑engineered Its Android Architecture for Scalability

This article chronicles the evolution of WeChat's Android architecture from a simple layered design through multi‑process and modular restructurings, explains why a major refactor was needed, and details the new communication, module, and code‑boundary strategies that enable faster development, better isolation, and a lightweight WeChat nano demo.

AndroidGradleMobile Development
0 likes · 28 min read
How WeChat Re‑engineered Its Android Architecture for Scalability
Tongcheng Travel Technology Center
Tongcheng Travel Technology Center
May 26, 2017 · Backend Development

Designing a Router Framework for Decoupling Modules in Large‑Scale Projects

The article analyzes the challenges of tightly coupled modules in rapidly growing projects, proposes a Router model that encapsulates and distributes inter‑module calls, discusses its core concepts, implementation options, and extensions such as interceptors, and shares practical lessons learned after two years of use.

GradleJavadependency management
0 likes · 10 min read
Designing a Router Framework for Decoupling Modules in Large‑Scale Projects
21CTO
21CTO
Mar 28, 2017 · R&D Management

Why Software Architectures Decay Over Time and How to Prevent It

Long‑running projects inevitably see their initial excitement with new frameworks fade as codebases grow, builds slow, and teams expand, leading to architectural decay; this article explains the causes, stages, and practical strategies—such as modularization, progressive builds, and disciplined technology adoption—to mitigate the problem.

Build Optimizationcodebase decaycontinuous integration
0 likes · 24 min read
Why Software Architectures Decay Over Time and How to Prevent It
Architecture Digest
Architecture Digest
Mar 27, 2017 · Fundamentals

Why Software Architectures Decay and How to Mitigate It

The article explains how long‑running software projects inevitably suffer architectural decay due to growing codebases, slower builds, and team turnover, and presents practical strategies such as environment upgrades, staged and distributed builds, modular isolation, and platform‑plus‑app designs to keep systems sustainable.

Build Optimizationarchitectural decaymodularization
0 likes · 23 min read
Why Software Architectures Decay and How to Mitigate It
Architecture Digest
Architecture Digest
Mar 25, 2017 · Backend Development

Design and Implementation of Alibaba Detail Platform: Modularization, Front‑Back Separation, and Platformization

This article describes the background, terminology, design principles, and detailed implementation of Alibaba's Detail platform, covering modular architecture, front‑back separation, module refactoring, stability, testing, continuous integration, deployment structures, and real‑world use cases.

backend developmentcontinuous integrationfrontend backend separation
0 likes · 16 min read
Design and Implementation of Alibaba Detail Platform: Modularization, Front‑Back Separation, and Platformization
Architecture Digest
Architecture Digest
Feb 19, 2017 · Fundamentals

Why Software Architectures Decay Over Time and How to Mitigate It

This article examines why long‑running software projects experience architectural decay, the limitations of new frameworks, and presents practical solutions such as environment upgrades, phased and distributed builds, refactoring into isolated components, and adopting modular, loosely‑coupled platform‑plus‑application designs to sustain development productivity.

Build Optimizationarchitecturecontinuous integration
0 likes · 22 min read
Why Software Architectures Decay Over Time and How to Mitigate It
Architecture Digest
Architecture Digest
May 20, 2016 · Mobile Development

Evolution of Mobile App Architecture: From MVC to Modularization with CocoaPods, Middleman, and URL Routing

The article traces the progressive evolution of a mobile app's architecture—from an initial MVC structure that quickly becomes tangled, through modular designs using CocoaPods, to advanced decoupling techniques like the middleman pattern and URL routing—highlighting practical lessons for small teams and larger enterprises.

CocoaPodsURL routingiOS development
0 likes · 8 min read
Evolution of Mobile App Architecture: From MVC to Modularization with CocoaPods, Middleman, and URL Routing