GIT Basics: Key Features and Advantages for Teams

Main Topics:

What is GIT?

Git is a powerful distributed version control system designed to facilitate collaboration among teams by tracking changes in a repository (a structured collection of files and directories). It meticulously logs the history of all modifications made, enabling users to review alterations, revert to previous states, and manage the contributions of multiple team members effectively.

  • Repository: Is a remote place from a hosting server provider (GitHub, GitLab, etc) where your project files are stored. It keeps a complete history of all changes made to those files, allowing you to see what has been modified and go back to earlier versions if needed.

  • Commit: Each time a change is made, it’s saved as a "commit." A commit captures a snapshot of the project at that moment and includes a message describing what was changed, which helps team members understand the project’s history.

  • Staging: Before saving changes as a commit, GIT allows you to stage them. The staging area acts as a holding space where you can select which changes to include in your next commit.

  • Push: After making and committing changes, you can push them to a remote repository,making them accessible to the entire team for the latest updates.

  • Branching: GIT enables you to create branches for different features or changes. This allows multiple team members to work on separate parts of the project without interfering with the main codebase. Once a task is completed, it can be merged back into the main branch.

  • Pull: Download the latest changes from the remote repository to your local copy.
  • Merge: When branches are combined, Git automatically merges changes and can flag conflicts for manual resolution, ensuring a smooth integration of different contributions.

  • Rebase: This operation allows users to apply their changes on top of another branch, creating a linear project history that can simplify collaboration.

    • What Makes GIT Essential for Teams?

  • Enhaces Teamwork: Multiple team members can work at the same time without conflicts.
  • Maintains version history: Keeps track of changes, making it easy to go back to previous versions.
  • Ensures data security and privacy: Safely stores changes, allowing teams to quickly recover from mistakes and protect sensitive information.
  • Facilitates collaboration: Easy sharing of work through remote repositories on platforms like GitHub or GitLab.
  • Supports synchronization: Team members can get the latest updates and share their changes easily.
  • Manages conflicts: Offers tools to resolve any issues that come up when changes overlap.

    • GIT for Teams

    GIT Fundamentals: Key Points to Remember

    Git is widely used in software development for tracking changes in source code, allowing multiple developers to work simultaneously without interfering with each other's contributions. Git’s versioning capabilities enable easy rollback to previous states in case of errors.

    While GIT can be used directly from the command line, many developers prefer to use tools that integrate with GIT. for ease of use and productivity:

    • GitHub - a platform with a user-friendly interface and powerful collaboration tools.
    • GitLab - a complete DevOps platform with tools for every stage of the software development lifecycle.
    • Bitbucket - integrates seamlessly with other Atlassian products like Jira and Confluence.

    GIT Workflow

    GIT Diagram

    Understanding GIT Structure

    • Workspace: This is the local folder where the actual project files are stored. Any modifications made here are considered untracked until they are intentionally staged for a commit.
    • Staging Area:The staging area serves as a bridge between the workspace and the local repository. Files placed in this area are staged and prepared for the next commit.
    • Local Repository: This is your personal repository on your computer. It contains all your project files and the complete history of changes. When you commit changes, they are saved here.
    • Remote Repository: A hosted provider space where project updates are stored and shared, allowing team members to push and pull changes while maintaining a synchronized workflow across the team.

    GIT Commands

    • Clone: Copy the remote repository to your local machine, including all files and history.
    • Push: Upload your local commits to the remote repository, sharing your changes.
    • Pull: Download and integrate changes from the remote repository into your local repository.

    Tips for Managing a GIT Repository

    To begin, you'll need a repository URL from a remote hosting provider (like GitHub, Bitbucket, GitLab, or a corporate GIT server).

    1. Organize Your Repository: Create separate folders for each database and a SHARED folder for files you wish to share with teammates. This keeps each person’s database isolated, minimizing accidental modifications.
    2. Use Subfolders for Shared Files: Inside each database folder, set up a subfolder (e.g., /shared) for shared tables. Team members can place their shared tables here, clearly labeled with the table name and version.

      3. Example: Repository Example

    3. Staging, Committing, and Pushing Changes: When a coworker updates a shared table, they stage and commit their changes from their /shared folder, then push them to the repository.
    4. Pulling Updates for Shared Tables: Team members can pull from the repository to obtain the latest changes, updating their own databases along with shared tables.
    5. Using Branches for Specific Changes: For larger or experimental changes to shared tables, coworkers can create branches for updates. Once tested, they can merge the branch back into the main branch with a pull request, preserving a clean history and reducing conflicts.
    6. Resolving Conflicts: If two team members edit the same shared table, Git will flag a merge conflict. They should collaborate to resolve the conflict, selecting the appropriate changes before committing the final version.
    7. Incorporating Shared Tables Locally: After pulling updates, coworkers can import shared tables into their databases, enabling continued work with the latest versions while maintaining their individual projects.