Shallow clones with depth in Git - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of shallow clone with depth 1

What is the output of the following command when cloning a large repository with many commits?

git clone --depth 1 https://github.com/example/repo.git

Choose the most accurate description of the clone result.

Git

git clone --depth 1 https://github.com/example/repo.git

A The repository is cloned with only the latest commit and no earlier history.

B The repository clone fails because depth must be greater than 1.

C The repository is cloned with the full commit history but no tags.

D The repository is cloned with all branches but only the last 10 commits each.

💡 Hint

Think about what the --depth option limits in a git clone.

Using --depth 1 creates a shallow clone with only the latest commit, reducing download size and time.

🧠 Conceptual

intermediate

Effect of shallow clone on git log

After cloning a repository with git clone --depth 3, what will git log show compared to a full clone?

A The log will show commits from all branches, but only 3 per branch.

B All commits will be shown but with limited details.

C Only the last 3 commits will be shown in the log.

D No commits will be shown until the full history is fetched.

💡 Hint

Consider what shallow cloning limits in the commit history.

A shallow clone with depth 3 contains only the latest 3 commits, so git log shows only those.

🔀 Workflow

advanced

Extending a shallow clone depth

You cloned a repository with git clone --depth 1. Later, you want to fetch more history to depth 5. Which command correctly extends the shallow clone to include the last 5 commits?

A git fetch --unshallow --depth=5

B git pull --depth 5

C git clone --depth 5

D git fetch --depth=5

💡 Hint

Think about how to fetch more commits after cloning shallowly.

Using git fetch --depth=5 extends the shallow clone to include the last 5 commits.

❓ Troubleshoot

advanced

Error when pushing from a shallow clone

You cloned a repository with git clone --depth 1 and made commits locally. When you try to push, you get an error:

error: refusing to push because the remote contains work that you do not have locally

What is the most likely cause?

A The shallow clone lacks full history, so git cannot verify the push is safe.

B You forgot to add files before committing.

C The remote repository is read-only.

D Your local branch is not tracking any remote branch.

💡 Hint

Consider how shallow clones affect push operations.

Shallow clones have incomplete history, so git refuses to push to avoid overwriting unknown commits.

✅ Best Practice

expert

Choosing shallow clone depth for CI pipelines

In a continuous integration (CI) pipeline, you want to speed up builds by cloning only necessary commits. Which depth value is best practice to balance speed and build correctness?

A Use full clone without depth to avoid any issues with missing history.

B Use depth 50 to include enough history for most build tools and tests.

C Use depth 1 to clone only the latest commit for fastest builds.

D Use depth 0 to clone no commits and fetch them later as needed.

💡 Hint

Think about the tradeoff between speed and completeness in CI.

Depth 50 often provides enough history for build tools while keeping clone time reasonable.

Practice

1. What does the --depth option do when used with git clone?

easy

A. It compresses the repository to save disk space.

B. It clones all branches including remote ones.

C. It creates a shallow clone with limited commit history.

D. It initializes a new empty repository.

Solution

1. Step 1: Understand the purpose of --depth

   The --depth option limits the number of commits cloned, creating a shallow copy.

2. Step 2: Compare with other clone types

   Unlike a full clone, a shallow clone saves time and space by copying recent commits only.

3. Final Answer:

   It creates a shallow clone with limited commit history. -> Option C

4. Quick Check:

   Shallow clone = limited history [OK]

Hint: Remember: --depth limits commit history depth [OK]

Common Mistakes:

• Thinking --depth clones all branches
• Confusing shallow clone with compression
• Assuming it creates an empty repo

2. Which of the following is the correct syntax to clone a repository with a depth of 5 commits?

easy

A. git clone --depth=5 https://example.com/repo.git

B. git clone -depth 5 https://example.com/repo.git

C. git clone --depth 5 https://example.com/repo.git

D. git clone --deep 5 https://example.com/repo.git

Solution

1. Step 1: Recall correct git clone syntax for depth

   The correct syntax uses --depth with an equals sign or a space and the number, like --depth=5 or --depth 5. Both are valid.

2. Step 2: Identify incorrect options

   git clone -depth 5 https://example.com/repo.git uses a single dash which is invalid. git clone --deep 5 https://example.com/repo.git uses an invalid flag --deep.

3. Final Answer:

   git clone --depth=5 https://example.com/repo.git -> Option A

4. Quick Check:

   Correct syntax = --depth=5 or --depth 5 [OK]

Hint: Use --depth=5 or --depth 5 for shallow clone [OK]

Common Mistakes:

• Using '=' instead of space after --depth (both valid but some prefer equals)
• Typing -depth instead of --depth
• Using --deep instead of --depth

3. What will be the output of the following commands?

git clone --depth 2 https://example.com/repo.git
cd repo
git log --oneline

medium

A. Shows commits from all branches.

B. Shows the full commit history.

C. Shows no commits because depth is too low.

D. Shows only the last 2 commits in the log.

Solution

1. Step 1: Understand shallow clone effect on history

   Using --depth 2 clones only the last 2 commits, so git log shows those.

2. Step 2: Analyze git log --oneline output

   This command lists commits in short form, limited to the shallow clone's depth.

3. Final Answer:

   Shows only the last 2 commits in the log. -> Option D

4. Quick Check:

   Depth 2 clone shows 2 commits [OK]

Hint: Shallow clone limits log to depth commits [OK]

Common Mistakes:

• Expecting full history in shallow clone
• Thinking no commits show if depth is low
• Assuming all branches' commits appear

4. You ran git clone --depth 3 https://example.com/repo.git but later need the full history. What should you do to fix this?

medium

A. Run git fetch --unshallow inside the cloned repo.

B. Delete the repo and clone again without --depth.

C. Run git clone --depth 0 to get full history.

D. Run git pull --depth=full to fetch all commits.

Solution

1. Step 1: Understand how to convert shallow clone to full

   Inside the shallow clone, running git fetch --unshallow downloads the full commit history.

2. Step 2: Evaluate other options

   Deleting the repo and cloning again without --depth works but is inefficient. Options C and D use invalid syntax or commands.

3. Final Answer:

   Run git fetch --unshallow inside the cloned repo. -> Option A

4. Quick Check:

   Use git fetch --unshallow to get full history [OK]

Hint: Use git fetch --unshallow to complete shallow clone [OK]

Common Mistakes:

• Trying to reclone instead of fetching full history
• Using invalid git pull options
• Assuming --depth 0 is valid

5. You want to clone a large repository but only need the last 10 commits of the main branch and no other branches. Which command achieves this efficiently?

hard

A. git clone --depth=10 https://example.com/repo.git

B. git clone --depth 10 --single-branch --branch main https://example.com/repo.git

C. git clone --branch main https://example.com/repo.git

D. git clone --shallow-since=10days https://example.com/repo.git

Solution

1. Step 1: Identify options to limit clone depth and branches

   Use --depth 10 to limit commits and --single-branch --branch main to clone only main branch.

2. Step 2: Check other options for correctness

   git clone --depth=10 https://example.com/repo.git clones all branches shallowly. git clone --branch main https://example.com/repo.git clones full history of main. git clone --shallow-since=10days https://example.com/repo.git uses invalid flag.

3. Final Answer:

   git clone --depth 10 --single-branch --branch main https://example.com/repo.git -> Option B

4. Quick Check:

   Depth + single branch = efficient clone [OK]

Hint: Combine --depth with --single-branch for focused clone [OK]

Common Mistakes:

• Not using --single-branch clones all branches
• Using invalid flags like --shallow-since
• Assuming --depth=10 clones only main branch