Large-scale project management strategies

Large-Scale Project Management Strategies

Large projects typically involve collaboration among multiple teams, complex codebase structures, and long-term maintenance requirements. Git, as a distributed version control system, can effectively support the development workflow of such projects. The key lies in proper planning of repository structure, branching strategies, permission management, and automation toolchains.

Repository Organization Structure

For projects exceeding 500,000 lines of code, the choice between a single repository (monorepo) or multiple repositories (polyrepo) directly impacts development efficiency. The monorepo model adopted by companies like Google is suitable for tightly coupled components:

// Typical monorepo directory structure
project-root/
├── packages/
│   ├── core-lib/      # Core library
│   ├── web-app/       # Frontend application
│   └── mobile-app/    # Mobile application
├── scripts/
│   ├── build.js       # Unified build script
│   └── deploy.js      # Deployment script
└── docs/             # Global documentation

The polyrepo approach is more suitable for independently evolving services but requires additional coordination of dependency versions. Tools like Lerna can bridge these two models:

# Using Lerna to manage cross-package dependencies
lerna add lodash --scope=core-lib

Branch Management Strategy

Git-flow is no longer suitable for very large projects; a trunk-based development variant is recommended instead. Key branches include:

• main: Stable branch corresponding to the production environment
• release/*: Version release branches
• feature/*: Short-lived feature branches (lifecycle < 2 days)
• hotfix/*: Emergency fix branches

# Example of creating a feature branch
git checkout -b feature/user-auth origin/main
git push -u origin feature/user-auth

For modules requiring long-term development, use branch namespaces for isolation:

team-ios/feature/payment-module
team-android/feature/camera-upgrade

Code Commit Standards

Mandatory commit message formats improve traceability:

[Module prefix] Action type: Description

Detailed explanation (optional)

Related ISSUE: #123

Example frontend commit:

git commit -m "[core] feat: Add JWT authentication middleware

- Implement RSA256-based token validation
- Add axios request interceptor

Related ISSUE: #PROJ-42"

Enforce validation via Husky hooks:

// .husky/commit-msg
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"

npx commitlint --edit "$1"

Permission Control Model

Layered permission management is crucial for large teams:

GitLab protected branch configuration example:

# .gitlab-ci.yml
protected_branches:
  - name: main
    push_access_level: maintainer
    merge_access_level: maintainer
    unprotect_access_level: admin

Code Review Process

Mandatory PR templates ensure review consistency:

## Change Type
- [ ] New feature
- [ ] Bug fix
- [ ] Documentation update

## Impact Scope
<!-- Describe affected modules -->

## Test Verification
- [ ] Unit tests passed
- [ ] E2E tests passed
- [ ] Manual test steps

## Screenshots/Recordings
<!-- Visual evidence -->

Combine with CODEOWNERS for automatic reviewer assignment:

# CODEOWNERS
/packages/core/ @team-architects
/packages/web/ @team-frontend-leads

Continuous Integration Strategy

Phased CI pipelines improve feedback speed:

# azure-pipelines.yml
stages:
- stage: precheck
  jobs:
    - job: lint
      steps: [npm run lint]
    - job: unittest
      steps: [npm test]

- stage: build
  dependsOn: precheck
  jobs:
    - job: bundle
      steps: [npm run build]

- stage: deploy
  condition: succeeded()
  jobs:
    - job: staging
      steps: [npm run deploy:staging]

For micro-frontend architectures, incremental builds are particularly important:

// webpack.config.js
module.exports = {
  cache: {
    type: 'filesystem',
    buildDependencies: {
      config: [__filename]
    }
  }
}

Dependency Management Practices

Large projects require strict control of third-party dependencies:

1. Use lock files to pin versions

npm install --save-exact react@18.2.0

2. Regular security audits

npx npm audit --production

3. Internal private registry management

# .npmrc
registry=https://registry.npmjs.org/
@my-company:registry=https://npm.pkg.github.com/

Documentation Automation

Generate changelogs from Git commits:

// scripts/changelog.js
const conventionalChangelog = require('conventional-changelog')

conventionalChangelog({
  preset: 'angular',
  releaseCount: 2
}).pipe(process.stdout)

Keep API documentation synchronized with code:

/**
 * @api {post} /login User login
 * @apiVersion 1.0.0
 * @apiGroup Auth
 * 
 * @apiParam {String} username Login account
 * @apiParam {String} password Password (MD5 encrypted)
 */
app.post('/login', authController.login)

Performance Optimization Techniques

Accelerate operations in large repositories:

1. Partial cloning to reduce download size

git clone --filter=blob:none https://repo.git

2. Sparse checkout of specific directories

git sparse-checkout init --cone
git sparse-checkout set packages/core

3. Use commit-graph

git config --global core.commitGraph true
git commit-graph write

Issue Tracking Integration

Link Git commits with Jira issues:

git commit -m "PROJ-123 Fix null pointer exception"

Regex pattern for automatic issue closing:

// .github/workflows/close-issue.yml
on: push
jobs:
  close-issue:
    runs-on: ubuntu-latest
    steps:
      - uses: actions-ecosystem/action-close-issue@v1
        with:
          comment: "Fixed by commit ${GITHUB_SHA}"

Cross-Team Collaboration

Use fork workflow to avoid main repository chaos:

git remote add upstream https://main-repo.git
git fetch upstream
git merge upstream/main

Regularly synchronize code standards:

// .editorconfig
[*.{js,ts}]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true

History Maintenance

Clean up commits containing sensitive data:

git filter-branch --force --index-filter \
  "git rm --cached --ignore-unmatch config/db.yml" \
  --prune-empty --tag-name-filter cat -- --all

Rewrite history for large files:

git lfs migrate import --include="*.psd" --everything