Tagged articles
project structure
31 articles · Page 1 of 1
This tutorial guides you through creating a Scrapy project on Windows, from activating a virtual environment and running scrapy startproject to examining the generated file structure and understanding the purpose of each core file like settings.py, pipelines.py, and spiders.
PythonTutorialpipelines
0 likes · 6 min read

This article explains Scrapy's asynchronous architecture built on Twisted, details its five core components (Engine, Scheduler, Downloader, Spiders, Item Pipeline) and middleware, then walks through creating a project with scrapy startproject, the generated directory structure, and running a spider via scrapy crawl.
Async FrameworkPythonTwisted
0 likes · 7 min read

The article explains why a FastAPI backend should move from a single main.py file to a responsibility‑layered architecture, detailing the recommended directory layout, pydantic‑settings configuration, SQLModel SQLite integration, APIRouter modular routing, and the resulting test coverage.
APIRouterBackendFastAPI
0 likes · 5 min read

This article explains why the default Django project layout is unsuitable for production, then presents a detailed, battle‑tested directory structure, split settings, environment variable management, organized apps, services, selectors, testing layout, Makefile shortcuts, and Django 5.2 considerations to help developers create maintainable, secure, and scalable Django applications.
BackendDevOpsDjango
0 likes · 14 min read

Learn how to create a modular Python script that batch processes Excel files—merging, cleaning, renaming, and more—using pandas and openpyxl, with a clear project structure and extensible design for real-world office automation.
Excel AutomationPandasPython
0 likes · 7 min read

This guide outlines how to establish clear code conventions, design a standardized Python project layout, and automate enforcement with tools like Black, Flake8, pre‑commit hooks, and CI pipelines, while integrating documentation, code reviews, and regular refactoring into the team workflow.
API testingCI/CDCode style
0 likes · 6 min read

This article explains how to organize a Python project with a conventional directory layout, follow PEP 8 naming and formatting rules, and use automated tools such as Flake8, Black, and isort to enforce code quality and streamline collaboration.
code-qualitypep8project structure
0 likes · 6 min read

This article compares two primary FastAPI project structure strategies—file‑type based and module‑function based—explaining why a well‑organized architecture improves scalability, maintainability, and team collaboration, and provides concrete directory layouts and best‑practice guidelines for building robust backend applications.
FastAPIPythonbackend development
0 likes · 9 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

This article walks you through why CMake is a more elegant, cross‑platform alternative to hand‑written Makefiles, explains its core benefits, and provides a complete, hands‑on tutorial that covers the basic workflow, a minimal project example, multi‑source handling, and multi‑directory organization with clear code snippets.
C++CMakeMakefile
0 likes · 13 min read


21CTODec 22, 2024 · Backend Development
This tutorial walks new Go developers through naming a project, initializing a module, creating the essential directory layout and files, adding tests, and building a simple CLI while emphasizing Go's KISS and YAGNI principles.
Gobackend developmentmodule initialization
0 likes · 8 min read

This article presents a Python parking‑lot management application, detailing its directory layout, explaining each module such as button handling, OCR utilities, and time processing, and showcasing the main pygame‑based code that renders parking information and visualizes remaining spaces.
Pandasparkingproject structure
0 likes · 5 min read

This article explains the principles and recommended layout for organizing a large Go web project, covering readability, extensibility, standard Go project layout, and detailed descriptions of directories such as /cmd, /internal, /pkg, /configs, /deployments, and supporting files to improve maintainability and scalability.
Webgolang-standardsinternal
0 likes · 11 min read

This article reviews four popular Python project scaffolding and build tools—CookieCutter, PyScaffold, PyBuilder, and Poetry—explaining their installation, generated directory structures, and typical make‑style commands for testing, documentation, and packaging.
build-toolsproject structure
0 likes · 11 min read

This guide outlines a comprehensive Go project layout—including cmd, pkg, internal, test, configs, and docs directories—alongside modular design principles, middleware usage, dependency injection, error handling, logging, database access layers, testing strategies, performance tuning, and documentation practices to improve code readability, maintainability, and scalability.
Godependency-injectionmiddleware
0 likes · 26 min read

This guide walks through the automatically generated Gin framework project, detailing the directory layout—including API, model, service, config, database, migrations, public assets, routers, runtime, and utils—while providing sample commands and code snippets that illustrate how to initialize, define interfaces, and perform CRUD operations with GORM.
GORMGinproject structure
0 likes · 6 min read

This article shares a comprehensive guide on front‑end project organization, directory conventions, coding standards, state‑management patterns, request abstraction, local storage handling, CSS modularization, Immer usage, npm private registry setup, template creation, CLI scaffolding, git workflow, and documentation practices, illustrated with practical TypeScript/React code examples.
Reactcode standardsengineering
0 likes · 21 min read

This article presents a comprehensive guide to building a Python backend project without controllers, covering modern dependency management with PDM, recommended project layout, module import conventions, static type checking using mypy, code formatting with Black, configuration handling, exception design, and testing strategies with pytest and tox.
ModulesPythoncode formatting
0 likes · 16 min read

This article reviews the fragmented state of Python project layout and build processes, compares four popular scaffolding and build tools—Cookiecutter, PyScaffold, PyBuilder, and Poetry—showing their installation commands, generated directory structures, and typical make/ tox workflows for packaging, testing, and documentation.
Build ToolsCookiecutterPoetry
0 likes · 13 min read

This article explains Maven's repository types, dependency declarations, version handling, conflict resolution strategies, best practices for early detection, standard directory layout, lifecycle phases, and scope definitions, providing a comprehensive guide for developers to master Maven in Java projects.
Dependency ManagementJavaLifecycle
0 likes · 10 min read

This article explains Maven’s repository types, dependency declaration, conflict resolution strategies, best‑practice tips, standard directory layout, lifecycle phases, and scope definitions, providing Java developers with the knowledge needed to use Maven confidently in multi‑module projects.
Dependency ManagementJavaMaven
0 likes · 10 min read

This guide walks you through the reasons for choosing Electron over browser‑based solutions, details the environment setup, installation steps, project initialization, core source‑code structure, main‑renderer architecture, and showcases complete example applications built with Electron‑Vue.
ElectronExample AppsVue
0 likes · 13 min read

This article explains why and how to read Nacos source code, covering the benefits of understanding underlying principles, code design patterns, and practical knowledge points, while providing step‑by‑step instructions for cloning the repository, exploring the project structure, launching the application, and tracing execution flow.
GitJavaNacos
0 likes · 11 min read

The article introduces the widely‑starred GitHub project “Node.js Best Practices,” highlighting its multilingual documentation, comprehensive coverage of project structure, error handling, coding standards, testing, production, security, and performance, and encourages readers to visit the repository for detailed guidance.
Best PracticesSecuritybackend development
0 likes · 2 min read

This guide walks you through Maven's repository types, dependency declarations, conflict resolution strategies, best‑practice checks, standard directory layout, lifecycle phases, and scope definitions, helping Java developers confidently manage multi‑module projects.
Dependency ManagementJavaLifecycle
0 likes · 10 min read


21CTOJun 16, 2019 · Backend Development
This guide explains IntelliJ IDEA’s Project Structure settings—including project name, SDK, language level, modules, sources, paths, dependencies, facets, libraries, and artifacts—detailing how to configure each element, manage sub‑projects, and prepare web deployment packages such as WAR and JAR files.
ArtifactsIntelliJ IDEAJava
0 likes · 7 min read

This article explains IntelliJ IDEA's Project Structure settings—including project name, SDK, language level, compiler output, modules, libraries, facets, and artifacts—detailing how each component works and how they affect building and deploying Java applications.
ArtifactsIntelliJ IDEAJava
0 likes · 8 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 comprehensive guide explains Python coding style best practices, covering PEP 8 extensions, flexible line length, naming conventions, docstring standards, functional versus object‑oriented design, testing, standard library usage, third‑party tools, and project structure to produce readable, maintainable code.
Best PracticesCode Readabilitycoding style
0 likes · 22 min read

This article discusses practical approaches to organizing a React project, comparing single‑file setups with modular multi‑file structures, component directories, testing strategies, data handling, and view integration, emphasizing pragmatic, maintainable architecture over rigid conventions.
Best PracticesComponent OrganizationFrontend Architecture
0 likes · 6 min read


21CTONov 21, 2015 · Mobile Development
This article reviews the architecture of several popular Android apps, extracts their strengths, and proposes a unified, modular project template that balances clarity and flexibility for multi‑app development, covering package layers, common modules, configuration, and best‑practice guidelines.
Android Architecturemodularizationproject structure
0 likes · 11 min read
