Tagged articles
code organization
48 articles · Page 1 of 1
The article shows how interleaving multiple data-flow chains in a method forces readers to context-switch, and demonstrates that simply reordering lines to follow each chain sequentially — without changing logic or extracting methods — dramatically improves readability, while explaining why method extraction can backfire when variables are shared across chains.
Clean CodeCode Readabilitycode organization
0 likes · 8 min read

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.
Design PrinciplesLayered ArchitectureOnion Architecture
0 likes · 9 min read

The article demonstrates how encapsulating each step of an order‑submission process into well‑named methods makes the core business flow instantly visible, lowers modification errors, and illustrates a coding habit of keeping all methods at the same abstraction level.
BackendClean CodeJava
0 likes · 5 min read

The article explains that layered architecture is not just a formalism for code organization but a fundamental safeguard that isolates responsibilities, changes, and replacements, preventing large systems from collapsing and enabling maintainable, scalable development.
Layered Architecturebackend developmentcode organization
0 likes · 4 min read

The article explains that difficulty reading code often stems from unfamiliar design patterns and complex construction logic rather than poor code quality, illustrating with factory and strategy patterns in inventory systems, and provides a checklist to distinguish between genuinely bad code and gaps in a developer’s knowledge.
Factory PatternJavaSpring
0 likes · 9 min read

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

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

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.
EncapsulationInner ClassesJava
0 likes · 4 min read

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

The article argues that complexity in software cannot be eliminated, only shifted to well‑defined places, explains why abstractions leak, explores the limits of local consequence, and shows how eliminating duplication and thoughtful layering can still reduce overall complexity.
abstractioncode organizationlocal consequence
0 likes · 9 min read

Learn why organizing Python code with functions, modules, and packages is essential for maintainable, scalable projects, and follow step‑by‑step examples that cover basic syntax, practical tips, package structures, dynamic imports, and a hands‑on mini‑project to build your own utility toolkit.
Best PracticesPythoncode organization
0 likes · 6 min read

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 styleService Layerbackend architecture
0 likes · 16 min read

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

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.
Vitecode organizationfrontend
0 likes · 11 min read

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

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.
Best PracticesDependency ManagementGo
0 likes · 30 min read

The article explains why treating business requirements as a logical tree and directly mapping that structure to code—using clear comments, proper function extraction, and avoiding premature design patterns—leads to more maintainable, bug‑free software.
Business LogicCoding Best Practicescode organization
0 likes · 8 min read

The article presents a front‑end API management approach that organizes CRUD functions into unified export statements, object‑oriented modules, and a central mapping table, demonstrating how these patterns improve code readability, maintainability, and development efficiency for large backend‑driven projects.
APIExportMapping
0 likes · 11 min read

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.
Bounded ContextFrontend Architecturecode organization
0 likes · 14 min read

This article explains how a Python team managing a codebase of nearly 28,000 modules introduced a layered architecture, enforced it with Import Linter, tracked technical debt, and discusses the benefits and drawbacks of such a structure for large‑scale backend development.
Layered Architecturebackend developmentcode organization
0 likes · 13 min read

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.
Layered ArchitecturePythoncode organization
0 likes · 15 min read

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


21CTOAug 11, 2023 · Backend Development
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.
Layered ArchitecturePythoncode organization
0 likes · 14 min read


政采云技术Feb 14, 2023 · Frontend Development
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.
DDDDomain-Driven DesignFrontend Architecture
0 likes · 13 min read

The article argues that complexity in software systems cannot be eliminated but only shifted, emphasizing the inevitability of leaks, the limits of local consequence, and the practical value of layering and eliminating duplication to make frequent changes easier and code more understandable.
ComplexityDesign Principlescode organization
0 likes · 8 min read

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.
backend architecturecode organizationdomain-driven design
0 likes · 14 min read

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.
Best PracticesFrameworksarchitecture
0 likes · 21 min read

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.
ComplexityDesign Principlescode organization
0 likes · 9 min read

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.
Domain ModelLayered ArchitectureService Layer
0 likes · 9 min read

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.
Go backendclean architecturecode organization
0 likes · 14 min read

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.
CargoRustcode organization
0 likes · 10 min read

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.
BEMBest PracticesCSS
0 likes · 11 min read

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

This guide shares practical Nest.js tips—including global API prefixes, modular folder structures, DTO usage, Data Mapper over Active Record, relative imports, data exclusion, getters, and barrel exports—to help developers build maintainable, version‑compatible backend services.
API DesignDTONest.js
0 likes · 7 min read

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

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.
Best PracticesComposition APILogic Reuse
0 likes · 12 min read

This article explains how to tackle intricate business logic by applying a top‑down structured decomposition, combining it with bottom‑up domain modeling, and using simple composition patterns, illustrated with a product‑on‑sale use case and concrete Java code examples.
code organizationdomain-driven designprocess decomposition
0 likes · 14 min read

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 LogicPolymorphismcode organization
0 likes · 14 min read

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.
code organizationdomain-driven designprocess decomposition
0 likes · 12 min read

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.
GoMVCRepository
0 likes · 4 min read

This article explains the BEM (Block‑Element‑Modifier) naming convention, why it is needed for style isolation, readability and maintainability, outlines its syntax and common patterns, and provides practical guidelines for page, shared, and local component naming in modern front‑end projects.
BEMCSSNaming Convention
0 likes · 10 min read

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.
Dependency ManagementHibernateJava
0 likes · 25 min read

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.
Inheritancecode organizationdesign patterns
0 likes · 10 min read

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

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


21CTOApr 24, 2016 · Mobile Development
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

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.
JavaScriptModular Developmentcmd
0 likes · 4 min read

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
