During migration to Git, what is the best strategy to preserve the commit history from the previous version control system?
- Create a mapping between old and new commits, ensuring each commit is accounted for.
- Discard the old commit history for simplicity.
- Convert all old commits into a single initial commit in Git.
- Use a third-party tool to import commits directly.
When migrating to Git, it's crucial to establish a mapping between old and new commits to preserve the commit history accurately. Discarding history or converting all commits into one may result in loss of valuable information. Using third-party tools can help in importing commits seamlessly.
What is an essential step in ensuring a smooth transition from a centralized VCS to Git?
- Train team members on Git fundamentals and best practices.
- Avoid training and let the team adapt on their own.
- Perform the migration without informing the team to minimize resistance.
- Hire external consultants to handle the transition.
Training team members on Git fundamentals and best practices is essential for a smooth transition. Avoiding training may lead to confusion, and informing and involving the team in the process helps mitigate resistance. Hiring external consultants may not address the internal team's needs effectively.
You're working on a feature in a separate branch and want to include recent changes from the main branch. What Git strategy should you use?
- Merge
- Rebase
- Cherry-pick
- Reset
When working on a separate branch and wanting to include recent changes from the main branch, the recommended Git strategy is to rebase. Rebasing incorporates changes from one branch into another and results in a cleaner, linear project history. Merging is another option, but it can create unnecessary merge commits. Cherry-pick and reset are not typically used for this scenario.
What is the importance of Git hooks in automating tasks in CI/CD pipelines?
- Code Deployment
- Code Review
- Automated Testing
- Task Automation
Git hooks are scripts triggered by Git events, such as pre-commit or post-merge. They play a vital role in CI/CD pipelines by automating tasks like code testing and deployment, ensuring a seamless development workflow.
To save changes in a new stash, you would use git stash ______.
- save
- create
- push
- store
The command to stash changes is git stash save, which saves the changes in the stash without committing them to the repository. This is useful when you need to switch to a different branch or address an urgent issue.
How should a distributed team structure their Git branches to optimize collaboration?
- Use feature branches for each team member
- Have a central repository with a single branch
- Implement a Git branching strategy, such as Gitflow
- Allow each team member to have their own repository
Distributed Team Branching
A Git Subtree allows you to keep a copy of an external repository in a subdirectory, treating it as a __________ project.
- separate
- nested
- linked
- subtree
The correct answer is subtree. Git subtree is a merging strategy that allows you to insert the contents of a repository into another one, but unlike submodules, the external repository becomes part of the history of the main repository. It is treated as a subtree within the main project.
To delete a tag in Git, use the command git tag -d ________.
- tag-name
- git-delete
- tag-delete
- git-rm
The correct option is a) tag-name. This command deletes the specified tag by providing the tag name after the -d option. It helps in removing unnecessary or incorrect tags from the repository.
When stashing changes, what happens to the staged and unstaged modifications in Git?
- Staged changes are preserved, unstaged changes are discarded
- Both staged and unstaged changes are preserved
- Staged changes are discarded, unstaged changes are preserved
- Both staged and unstaged changes are discarded
When you stash changes, Git saves both staged and unstaged changes. This allows you to switch branches without committing changes, and later apply the stash to continue working on the changes.
What is the purpose of the .gitignore file in a Git repository?
- Exclude specific files from version control
- Store sensitive data
- Track changes in the repository
- Create backups automatically
The .gitignore file is used to exclude specific files or patterns from being tracked by Git. This is helpful to avoid cluttering the repository with files that shouldn't be versioned, such as temporary files, build artifacts, or system-specific files.
What is a pull request in the context of Git?
- A way to request someone to pull your changes
- A command to pull the latest changes from the remote repository
- A request to merge two branches
- A request to undo the last commit
A pull request is a method used to propose changes to a repository. It allows collaborators to review and discuss the changes before merging them into the main branch. It typically includes details about the changes made and the reason for the changes. This is an essential part of the collaborative workflow in Git.
What is the main purpose of using Git Submodules?
- Code sharing between repositories
- Version control for individual files
- Merging branches
- Creating lightweight branches
Git Submodules are used for integrating external repositories as a subdirectory within a main repository. The main purpose is code sharing between repositories, allowing you to include external projects while keeping them isolated.