BestHub
Sign in
Tagged articles

code organization

45 articles · Page 1 of 1
IT Learning Made Simple
IT Learning Made Simple
Jul 3, 2026 · Fundamentals

Understanding the Development View: A Floor‑Plan for Code Organization

The article explains the Development View— the "code floor plan" in the 4+1 view model—by detailing how code is organized, directory structures, module dependencies, build and packaging configurations, common architectural patterns, design principles, and practical solutions to typical problems such as circular dependencies and package chaos.

code organizationdesign principleshexagonal architecture
0 likes · 9 min read
Understanding the Development View: A Floor‑Plan for Code Organization
IT Services Circle
IT Services Circle
Mar 4, 2026 · Fundamentals

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

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

code organizationrefactoringsoftware design
0 likes · 11 min read
Why utils.py Turns Into a Code Dump and 3 Better Alternatives
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.

code organizationdesign patternsmodularization
0 likes · 11 min read
Stop Using a Monolithic utils.py: 3 Design Patterns to Make Your Python Code Cleaner
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 27, 2025 · Backend Development

Mastering Java Inner Classes: Organize, Encapsulate, and Simplify Your Code

The article explains how Java inner classes can be used to encapsulate related functionality, access private members of the outer class, implement interfaces for callbacks, and hide implementation details, providing clear code examples such as Car/Engine, Counter/Incrementer, Button listeners, and a Calculator with an Operation inner class.

CallbacksEncapsulationInner Classes
0 likes · 4 min read
Mastering Java Inner Classes: Organize, Encapsulate, and Simplify Your Code
Deepin Linux
Deepin Linux
Aug 21, 2025 · Fundamentals

How to Eliminate C/C++ Header File Circular Includes and Speed Up Compilation

This article explains why circular header inclusion in C/C++ causes compilation errors and performance issues, and provides practical solutions such as include guards, #pragma once, forward declarations, better file organization, and the PIMPL pattern, along with real‑world examples and interview‑style Q&A.

#pragma onceC#circular inclusion
0 likes · 24 min read
How to Eliminate C/C++ Header File Circular Includes and Speed Up Compilation
DaTaobao Tech
DaTaobao Tech
May 14, 2025 · Backend Development

How a 2‑Year Journey Unified Java Backend Code Structure for Better Readability and Maintenance

This article shares a two‑and‑a‑half year effort to standardize code style and architecture across a large Java backend, detailing the origins, evolving patterns, a unified layered model, concrete implementation examples, measurable benefits, and future directions for continuous improvement.

Code styleDomain-Driven Designbackend-architecture
0 likes · 16 min read
How a 2‑Year Journey Unified Java Backend Code Structure for Better Readability and Maintenance
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.

Importcode organizationmodularization
0 likes · 7 min read
Understanding Python Modularization and Import Mechanisms
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Feb 9, 2025 · Frontend Development

Managing and Optimizing Import Statements in Frontend Projects

This article explains why import statements can fill an entire file, examines the problems caused by excessive imports, and presents practical techniques such as module re‑export, require.context, dynamic import, webpack ProvidePlugin, Vite plugins, TypeScript namespaces, aliasing, and Babel plugins to keep import sections concise and maintainable.

ImportVitecode organization
0 likes · 11 min read
Managing and Optimizing Import Statements in Frontend Projects
Raymond Ops
Raymond Ops
Jan 22, 2025 · Backend Development

10 Essential Go Practices to Write Flexible, Maintainable Code

This article presents ten practical Go programming techniques—from using a single GOPATH and wrapping for‑select loops to defining custom types, improving enum handling with iota, and encapsulating repetitive logic with context helpers—aimed at building flexible, readable, and easily maintainable applications.

GOPATHGocode organization
0 likes · 14 min read
10 Essential Go Practices to Write Flexible, Maintainable Code
BirdNest Tech Talk
BirdNest Tech Talk
Jan 16, 2025 · Backend Development

How to Organize a Go Project for Clean, Maintainable Code

This guide explains why structuring Go code by packages, layers, and standard directories—using conventions like cmd, internal, pkg, and clear interface boundaries—improves readability, testability, and long‑term maintainability while avoiding common pitfalls such as circular dependencies and oversized files.

GoProject Structurebest practices
0 likes · 30 min read
How to Organize a Go Project for Clean, Maintainable Code
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 11, 2023 · Frontend Development

How Domain-Driven Design Transforms Front-End Development

This article explains how applying Domain-Driven Design principles to front‑end projects clarifies business boundaries, improves code organization, reduces maintenance costs, and enables better collaboration across product, front‑end, and back‑end teams.

Frontend Architecturebounded contextcode organization
0 likes · 14 min read
How Domain-Driven Design Transforms Front-End Development
MaGe Linux Operations
MaGe Linux Operations
Aug 16, 2023 · Fundamentals

How Layered Architecture Keeps a 30K‑File Python Codebase Manageable

This article explains how a massive Python project with nearly 30,000 files uses a layered architecture and Import Linter to enforce dependency rules, reduce complexity, track technical debt, and improve maintainability, while also discussing the trade‑offs and practical implementation details.

Pythoncode organizationimport-linter
0 likes · 15 min read
How Layered Architecture Keeps a 30K‑File Python Codebase Manageable
Architect
Architect
Aug 12, 2023 · Backend Development

Understanding Code Architecture: Clean, Hexagonal, Onion, COLA and a Go Implementation Guide

This article explains why code architecture matters, compares Clean, Hexagonal, Onion and COLA patterns, describes their layered structures and separation‑of‑concerns principles, and provides a practical Go project layout with concrete code examples to illustrate how each layer interacts.

Clean Architecturecode organizationsoftware architecture
0 likes · 19 min read
Understanding Code Architecture: Clean, Hexagonal, Onion, COLA and a Go Implementation Guide
21CTO
21CTO
Aug 11, 2023 · Backend Development

How Layered Architecture Keeps a 28K‑File Python Monolith Manageable

This article explains how a massive Python codebase with over 27,000 modules is organized using a layered architecture, enforced with Import Linter, to reduce complexity, track technical debt, and enable independent development across clients and territories.

Pythoncode organizationimport-linter
0 likes · 14 min read
How Layered Architecture Keeps a 28K‑File Python Monolith Manageable
政采云技术
政采云技术
Feb 14, 2023 · Frontend Development

Analysis of Remesh: A Frontend DDD Framework

This article provides an in-depth analysis of Remesh, a frontend framework implementing Domain-Driven Design (DDD) principles, exploring its core concepts, advantages, and practical implementation.

CQRSDDDDomain-Driven Design
0 likes · 13 min read
Analysis of Remesh: A Frontend DDD Framework
Architecture Digest
Architecture Digest
Dec 28, 2022 · Backend Development

Methodology for Writing Complex Business Code: Structured Process Decomposition and Domain Modeling

This article presents a practical methodology for handling complex business scenarios by combining top‑down process decomposition with bottom‑up domain modeling, illustrating the approach with a retail product onboarding case, code examples, and guidance on capability sinking and model‑driven design.

Domain-Driven Designbackend-architecturecode organization
0 likes · 14 min read
Methodology for Writing Complex Business Code: Structured Process Decomposition and Domain Modeling
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 28, 2022 · Frontend Development

Why Frontend Frameworks Fail and How to Build Better Architecture

Modern front‑end frameworks like Vue and React have sparked a cult‑like devotion that often obscures deeper issues; this article examines the resulting complexity, argues that developers—not tools—are the key variable, and presents a layered, composable architecture with code examples to improve maintainability.

architecturebest practicescode organization
0 likes · 21 min read
Why Frontend Frameworks Fail and How to Build Better Architecture
Architect
Architect
Oct 30, 2022 · Fundamentals

Managing Complexity in Software Architecture

The article argues that complexity in software systems is unavoidable and must be consciously placed, managed, and reduced through thoughtful architectural decisions, prioritizing high‑frequency changes, eliminating duplication, and accepting that perfect local consequences are impossible.

code organizationcomplexitydesign principles
0 likes · 9 min read
Managing Complexity in Software Architecture
IT Architects Alliance
IT Architects Alliance
Apr 7, 2022 · Backend Development

Best Practices for Application Layering and Domain Model Design

This article explains the importance of clear responsibility separation in application layering, reviews Alibaba's recommended layer structure, proposes an optimized layering model, and discusses domain model conversions to improve code maintainability, reusability, and team collaboration.

code organizationdomain modellayered architecture
0 likes · 9 min read
Best Practices for Application Layering and Domain Model Design
Tencent Cloud Developer
Tencent Cloud Developer
Mar 8, 2022 · Backend Development

Go Microservices Architecture Best Practices Based on Clean Architecture and trpc-Go

The article presents clean‑architecture best practices for Go microservices built with trpc‑Go, recommending a four‑layer pyramid (gateway, logic, repo, entity), strict dependency inversion, interface‑based injection, gomock testing, centralized JSON configuration, and a three‑phase rollout to replace tangled packages and global imports while avoiding DDD complexity.

Clean ArchitectureDependency InjectionGo backend
0 likes · 14 min read
Go Microservices Architecture Best Practices Based on Clean Architecture and trpc-Go
ELab Team
ELab Team
Mar 2, 2022 · Fundamentals

Master Rust Module Organization: Simple Patterns for Cross-File Imports

This tutorial walks Rust beginners through three practical ways to declare and use modules across files, explains Cargo's file‑placement conventions, and shows how to reference sibling and external modules with the `use` and `super` keywords.

Importcargocode organization
0 likes · 10 min read
Master Rust Module Organization: Simple Patterns for Cross-File Imports
ELab Team
ELab Team
Sep 29, 2021 · Frontend Development

Mastering Clean CSS: Architecture, Naming Conventions, and Best Practices

This article explores how to write maintainable, readable, and scalable CSS by adopting consistent team guidelines, covering major architectures like OOCSS, BEM, SMACSS, ITCSS, and ACSS, as well as commenting, spacing, and core design principles for high‑quality front‑end code.

BEMPreprocessorarchitecture
0 likes · 11 min read
Mastering Clean CSS: Architecture, Naming Conventions, and Best Practices
Taobao Frontend Technology
Taobao Frontend Technology
Sep 10, 2021 · Frontend Development

Mastering Multi‑Platform Front‑End with the Strategy Pattern

This article walks through a real‑world multi‑app scenario, breaks down the core challenges, compares several implementation approaches—including naive if‑else, SDK abstraction, and the Strategy design pattern—and reflects on engineering trade‑offs to help front‑end engineers write cleaner, more maintainable code.

Frontend ArchitectureStrategy Patterncode organization
0 likes · 11 min read
Mastering Multi‑Platform Front‑End with the Strategy Pattern
vivo Internet Technology
vivo Internet Technology
Aug 18, 2021 · Mobile Development

Android App Modular Development Practice: A Comprehensive Guide

This guide explains how to adopt a multi‑project modular architecture for Android apps—distinguishing components from modules, outlining vertical and horizontal design layers, showing ARouter‑based navigation and communication, and detailing a top‑down, bottom‑up migration process used to refactor the vivo official app.

ARouterAndroid DevelopmentApp Architecture
0 likes · 15 min read
Android App Modular Development Practice: A Comprehensive Guide
Baidu App Technology
Baidu App Technology
May 14, 2021 · Frontend Development

Deep Dive into Vue 3 Composition API: Design, Analysis, and Practical Implementation

The article thoroughly examines Vue 3’s Composition API, explaining its motivation over the Options API, detailing its function‑based design and TypeScript advantages, addressing concerns about complexity, and offering practical guidance on when and how to adopt it for cleaner, more maintainable component logic.

Composition APILogic ReuseTypeScript
0 likes · 12 min read
Deep Dive into Vue 3 Composition API: Design, Analysis, and Practical Implementation
Alibaba Cloud Native
Alibaba Cloud Native
Oct 17, 2020 · Backend Development

Conquering Complex Business Logic: A Matrix Analysis Method to Eliminate if‑else

This article explains why excessive if‑else code harms maintainability, introduces polymorphic extension and code‑separation strategies, and presents a matrix‑analysis methodology that uses multi‑dimensional thinking to systematically design, model, and simplify complex business workflows.

business logiccode organizationcomplexity management
0 likes · 14 min read
Conquering Complex Business Logic: A Matrix Analysis Method to Eliminate if‑else
Architecture Digest
Architecture Digest
Sep 12, 2019 · Backend Development

Methodology for Writing Complex Business Code: Process Decomposition and Domain Modeling

This article presents a practical methodology for handling complex business logic by combining top‑down process decomposition with bottom‑up domain modeling, illustrating the approach with a detailed product‑on‑sale use case, code examples, and guidance on avoiding over‑reliance on tooling.

Domain-Driven Designcode organizationprocess decomposition
0 likes · 12 min read
Methodology for Writing Complex Business Code: Process Decomposition and Domain Modeling
360 Tech Engineering
360 Tech Engineering
May 17, 2019 · Backend Development

Guidelines for Organizing Go Projects: Structure of the gobox-demo Template

This article shares practical guidelines and a detailed directory layout for organizing Go projects, illustrated with the gobox-demo template, covering configuration, source code organization, controller/action separation, service layer structuring, and best‑practice recommendations for clean, maintainable backend development.

GoMVCProject Structure
0 likes · 4 min read
Guidelines for Organizing Go Projects: Structure of the gobox-demo Template
Java Captain
Java Captain
Nov 26, 2018 · Backend Development

Design and Implementation of a Reusable Java Backend Framework (lyyzoo)

This article details the design of a reusable Java backend framework called lyyzoo, covering coding standards, Maven module hierarchy, dependency management, core utility classes, and Spring configuration for web, JPA, and transaction support, providing a comprehensive guide for building enterprise applications.

HibernateJavaSpring
0 likes · 25 min read
Design and Implementation of a Reusable Java Backend Framework (lyyzoo)
Architecture Digest
Architecture Digest
Dec 4, 2017 · Fundamentals

Rethinking Object‑Oriented Programming: From Myth to Practical Understanding

The article reflects on a decade of programming experience to demystify object‑oriented programming, arguing that OOP should be taught as a practical tool for reducing complexity rather than an abstract doctrine, and discusses how to organize functions into classes, avoid misuse of inheritance and design patterns, and focus on solving real problems.

Programming Fundamentalscode organizationdesign patterns
0 likes · 10 min read
Rethinking Object‑Oriented Programming: From Myth to Practical Understanding
Qunar Tech Salon
Qunar Tech Salon
May 23, 2017 · Mobile Development

Ctrip Technical Salon: Mobile Development Practices and Performance Optimization – MVC, MVP and the Extended MVCPI Architecture

This article presents a detailed analysis of the evolution from MVC to MVP in Android hotel‑business development, illustrates common pitfalls such as bloated controllers and context loss, introduces Ctrip's extended MVCPI pattern with weakly‑typed IView, Presenter and Interactor components, and provides concrete code examples for each architecture.

AndroidMVCMVP
0 likes · 15 min read
Ctrip Technical Salon: Mobile Development Practices and Performance Optimization – MVC, MVP and the Extended MVCPI Architecture
Hujiang Technology
Hujiang Technology
Jan 10, 2017 · Frontend Development

Scaling React Applications: Containers vs Components, Feature‑Based Code Organization, CSS Modules, PostCSS Auto Reset, and Redux‑Saga

This article shares lessons learned from releasing React Boilerplate 3.0, covering the importance of front‑end scalability, the distinction between container and presentational components, feature‑based code organization, CSS Modules and PostCSS Auto Reset for style isolation, and using redux‑saga for readable, testable asynchronous flows.

CSS ModulesFrontend ArchitectureReAct
0 likes · 9 min read
Scaling React Applications: Containers vs Components, Feature‑Based Code Organization, CSS Modules, PostCSS Auto Reset, and Redux‑Saga
21CTO
21CTO
Apr 24, 2016 · Mobile Development

Why Android Apps Rely on Callbacks and How to Keep Your Code Clean

This article explains how most Android code is driven by event callbacks, examines single‑event and multi‑event implementations, discusses the pitfalls of bloated callbacks, and offers practical strategies to structure and simplify callback‑heavy code for clearer, more maintainable apps.

AndroidCallbackscode organization
0 likes · 7 min read
Why Android Apps Rely on Callbacks and How to Keep Your Code Clean
Java High-Performance Architecture
Java High-Performance Architecture
Sep 15, 2015 · Frontend Development

Why Non‑Modular JavaScript Is Painful and How CMD Solves It

Non-modular JavaScript leads to naming conflicts and tangled file dependencies, but adopting a module system like CMD eliminates these issues by encapsulating functionality, simplifying imports with define, require, and exports, and streamlining project structure for scalable front‑end development.

CMDJavaScriptModular Development
0 likes · 4 min read
Why Non‑Modular JavaScript Is Painful and How CMD Solves It
Baidu Tech Salon
Baidu Tech Salon
Sep 1, 2014 · R&D Management

How to Tame a Chaotic Codebase When Scaling Your Startup

The article shares a founder’s hard‑earned lessons on preventing code‑base entropy, hiring the right first engineer, and gradually improving code quality so that a growing startup can transition from a solo coder to a well‑structured engineering team.

R&D Managementcode organizationsoftware engineering
0 likes · 7 min read
How to Tame a Chaotic Codebase When Scaling Your Startup