Learning Path review questions: LP01

Learning Path review questions

1. What are two types of branching in Git?

In Git, branching allows you to work on different parts of your project simultaneously without affecting the main codebase. There are many ways to branch in Git, but two common types of branching are:

1. Feature Branching

Purpose:

Feature branching is a strategy where developers create a separate branch to work on a specific feature or functionality of the application. The idea is to keep development isolated from the main branch (usually main or master), ensuring that features can be developed without interrupting the stability of the codebase.

Workflow:

Once the feature is complete, the branch is merged back into the main branch after reviewing and testing.

Example:

• main (main production branch)

• feature/login-page (branch for working on login page functionality)

2. Release Branching

Purpose:

A release branch is used to prepare a new version of the application for production. It is created from the develop branch or main branch (depending on your workflow) and contains only the changes necessary to finalize the release.

Workflow:

This branch is used to fix bugs, perform final testing, and prepare documentation, without making new feature additions. Once the release is ready, it’s merged into both the main branch and the develop branch.

Example:

release/1.0.0 (branch for preparing version 1.0.0 of the app)

2. What are Git Hooks?

Git Hooks are scripts that run automatically in response to certain events in the Git lifecycle. They allow you to automate tasks like code formatting, running tests, and enforcing commit policies before changes are made to the repository.

Git hooks are stored locally in the .git/hooks directory of your repository and can be used for various tasks, such as:

1. Pre-commit hook: Runs before a commit is made. Often used for tasks like running linters or tests to ensure code quality before committing.

2. Post-commit hook: Runs after a commit is made. It can be used to trigger notifications or update an issue tracker.

3. Pre-push hook: Runs before a push operation. It’s useful for ensuring that code passes tests or meets other criteria before it is pushed to a shared repository.

4. Post-merge hook: Runs after a merge. Often used to notify teams of new changes or update dependencies.

Example:

• pre-commit: A hook that could run a linter (e.g., eslint) on your code before it’s committed.

• pre-push: A hook that runs tests to ensure they pass before pushing the changes to a remote repository.

Git hooks can be customized by editing the script files in the .git/hooks/ directory, and they can be shared within teams using tools like Husky (for JavaScript projects) or by checking them into the repository (with some caution, since Git hooks are typically not tracked by default).

3. Best Practices for Working with Files in Git

When using Git to manage a project, it's important to follow certain best practices to maintain a clean, efficient, and collaborative workflow.

General Best Practices for Working with Files in Git:

1. Use .gitignore effectively: Use a .gitignore file to specify which files or directories Git should not track (e.g., build artifacts, IDE configuration files, and sensitive information like passwords).

   Example:

   xxxxxxxxxx
   5
   1
   # Ignore all node_modules directories
   2
   node_modules/
   3
   # Ignore compiled files
   4
   .class
   5
   .exe
   

2. Commit often, but with meaningful messages: Break your changes into logical, small commits, and write clear, descriptive commit messages explaining what each commit does. Avoid large, monolithic commits, as they can make it difficult to trace issues in the future.

3. Branch appropriately: Use feature branches for new development, and keep your main or master branch stable. Use git rebase to maintain a clean, linear commit history when necessary, especially in collaborative workflows.

4. Avoid large binary files: Git is designed for handling text files, so large binary files (such as images, audio files, etc.) can slow down repository performance. Use Git LFS (Large File Storage) for tracking large files.

5. Pull changes frequently: Regularly pull from the remote repository to stay up-to-date with your team's changes and avoid merge conflicts.

Working with Large Files in Git:

Handling large files requires special consideration to avoid performance degradation. Git is optimized for handling text-based files and small binary assets, but large files can cause issues like bloated repository size and slower cloning/pulling operations.

Here are some best practices for working with large files:

1. Use Git LFS (Large File Storage):

Git LFS is an extension that allows you to store large files (such as images, audio, video, datasets, etc.) outside the Git repository, while keeping pointers to the files in the repository itself.

This keeps the repository size manageable while allowing you to track large files.

Example:

xxxxxxxxxx
5
1
git lfs install
2
git lfs track ".mp4"
3
git add .gitattributes
4
git add mylargefile.mp4
5
git commit -m "Add large file with Git LFS"

2. Avoid tracking unnecessary large files:

Use .gitignore to avoid committing large files that don’t need version control (like build artifacts, temporary files, or files generated by your IDE).

3. Consider storing large files externally:

If the files are not strictly necessary for version control, consider storing them in external services like Amazon S3, Google Drive, or Dropbox and simply keeping references or metadata in the repository.

4. Compress large files:

If you must commit large files (e.g., assets), consider compressing them to reduce their size before adding them to the repository.

Summary

1. Two types of branching in Git are Feature Branching and Release Branching, which help developers work on new features or prepare for production releases without disrupting the main codebase.

2. Git Hooks are scripts that automate actions during different stages of the Git lifecycle (e.g., pre-commit, pre-push) and help enforce workflows or policies.

3. Best practices for working with files in Git include using .gitignore to exclude unnecessary files, committing frequently with clear messages, and avoiding large binary files in the main repository. For large files, Git LFS (Large File Storage) is a popular solution to track and store large files efficiently.