Managing code in complex software projects is a significant challenge, and without tools that enable seamless collaboration among developers, continuously evolving code can become difficult to manage. In the development of modern applications and websites, Git has become an essential tool for developers as it helps track code changes, facilitates efficient collaboration among development teams, and aids in integration and code review for all versions. In this article, we will introduce you to Git, a tool for version control, and how to use Git from basic to advanced techniques that every professional developer should know.

What is Git?

Git is a version control system (VCS) used to track changes in program code or various files developed in software projects. Git allows developers to revert to previous versions of the code in case of errors and facilitates effective team collaboration without worrying about code conflicts when multiple developers are working on the same code. Git enables tracking code changes in each version, creating code branches for simultaneous feature development, and merging code from multiple branches without redundancy or conflicts.

Git vs Other Version Control Systems

Before Git became popular in web and app development, developers typically used centralized version control systems (such as CVS or Subversion), which store versioned files in a central database. This required all team members to connect to the central database to access the information, which could slow down work or lead to issues if the central database failed. Git is a Distributed Version Control System (DVCS), which means each team member has a local copy of the code and its change history. This distributed approach allows each individual to work independently without relying on a central database, and the connection between multiple users is faster and more efficient.

Git Working Principles

1. Commit History
   Git tracks changes every time a commit is made. A commit is the act of saving the changes made to the code, along with a commit message that describes what was changed in the code.

2. Branches
   Git allows developers to create branches to develop code separately, such as working on new features or fixing bugs without affecting the main code (master or main branch). Using branches helps keep the work organized, and once the work is complete, it can be merged into the main code without any issues.

3. Merging
   Merging refers to bringing changes from different branches back into the main code. For example, merging new features developed in a sub-branch into the master branch. Git manages this process seamlessly without causing conflicts.

4. Distributed Model
   In Git, each team member has their own copy of the repository (local repository), allowing them to work even without an internet connection. Once connected to the internet, changes can be shared with the remote repository (e.g., GitHub or GitLab).

Advantages of Using Git

1. Efficient Collaboration
   With Git, developers can work on different branches without worrying about conflicts. Using branches allows team members to work independently, and once a feature is ready, it can easily be merged back into the main code.

2. Effective Version Management
   Git makes it easy to track changes and record versions of the code. You can easily revert to previous versions if issues arise and view the history of code changes.

3. Control Changes from Multiple Sources
   Git supports working from multiple sources (distributed), allowing the team to work from anywhere and efficiently update and merge changes from different sources.

4. Security and Backup
   Using Git ensures that code data is safely backed up and can be easily recovered, as each team member has a copy of the code on their local machine. This avoids issues in case the main server data is lost.

5. Support for Large-Scale Projects
   Git is ideal for managing large projects with millions of lines of code and multiple teams collaborating. It ensures smooth version management and organized teamwork.

Git and Collaboration in Development Teams

In software projects with multiple developers, Git is an essential tool that enables effective teamwork. Developers can create branches to experiment with new code or make fixes without affecting the main codebase. Once a feature is complete, it can be merged back into the main code. GitHub or GitLab are tools that work with Git, making teamwork easier by allowing everyone on the team to share code changes conveniently, with features like Pull Requests, Code Reviews, Issue Management, and Continuous Integration (CI) testing.

Why is Git important for developers?

Using Git for version control is crucial for developers working on web applications or software at all levels. Whether you're a beginner or part of an experienced team, Git helps manage code changes efficiently, enabling control, tracking, and collaboration with the team. Understanding the importance of Git empowers developers to work confidently and more effectively. In this section, we’ll discuss the reasons why Git is essential for code development and team collaboration.

1. Version Control and Tracking Changes

One of the key features of Git is its ability to track and manage code changes across all versions. Every edit or new development is recorded in Git, allowing you to revert to a previous version whenever needed. If an unexpected bug or issue arises, you can quickly roll back to a working version. Additionally, Git lets you see who made which changes and when, which is crucial for team collaboration in a development project.

2. Collaboration in Development Teams

Working with Git in a development team allows multiple developers to collaborate effectively on the same project. Without worrying about code conflicts or errors during code merges, Git helps everyone on the team create separate branches for different tasks such as developing new features, fixing bugs, or testing. These changes won't impact the main codebase (master branch) and can be merged back once complete.

3. Branching and Merging

One of the features that makes Git essential is the ability to create branches, allowing you to work on code separately from the main codebase. For example, creating a new feature or fixing bugs without affecting the existing code. Branching enables developers to work independently, and once a feature is completed, it can be merged back into the main branch without issues. Additionally, Git supports merging code from multiple branches seamlessly, making collaboration among developers more efficient.

4. Speed

Git helps developers work faster by providing tools that support efficient collaboration. For instance, creating branches for different features or bugs allows development and testing to be done simultaneously. Git also makes it easy and quick to modify or update code, without having to waste time reviewing or duplicating code.

5. Code Maintenance and Auditing

With Git, developers can easily audit and maintain code. If issues or errors arise, you can revert to a previous version of the code that worked correctly, or trace how a change caused the problem. Maintaining code in the long term is also easier, as Git allows you to manage and differentiate between different versions of code without having to store multiple copies of the same file.

6. Support for Large Projects

For large-scale projects with many teams working together, Git is a tool that effectively handles large codebases. It allows efficient management of data or complex structures in large projects, making collaboration smoother without slowing down the system. Git ensures that working with millions of lines of code in large projects remains efficient and manageable.

 

Basic Git Commands Every Developer Should Know

1. git init

The git init command is used to create a new repository on your local machine for a new project that hasn't yet used Git for version control.

git init

2. git clone

git clone https://github.com/username/repository.git

3. git add

The git add command is used to add files that you want to track or stage for the next commit.

git add <filename>

used to add all files:

git add .

4. git commit

git commit -m "ข้อความที่อธิบายการเปลี่ยนแปลง"

5. git push

The git push command is used to upload the committed changes to a remote repository, such as GitHub or GitLab. This allows others to access and collaborate on the updated code in the remote repository.

git push origin master

6. git pull

The git pull command is used to fetch the latest changes from a remote repository and merge them with the code on your local machine. This ensures that your local copy is up to date with the latest changes made by others.

git pull origin master

7. git branch

The git branch command is used to view the status of branches in a repository or to create a new branch. You can list all existing branches with this command, and it also allows you to create and manage branches within the repository.

git branch

used to add all files:

git branch <branch_name>

8. git merge

The git merge command is used to merge changes from one branch into another. For example, if you want to merge changes from a feature branch (e.g., dev) into your main branch (e.g., master or main), you can follow these steps:

git merge <branch_name>

Using Git with GitHub

Using Git with GitHub is one of the most popular ways to manage software projects. GitHub is a platform that helps store, share, and manage code that uses Git efficiently. The collaboration between Git and GitHub helps development teams manage code versions more effectively, collaborate conveniently, and easily perform code reviews. GitHub is an online service for managing Git repositories that can be used both for free and with a paid plan. GitHub supports the use of Git for version control, team collaboration, and managing large projects.

Advantages of Using Git with GitHub

1. Convenient Collaboration
   GitHub helps developers collaborate on the same project efficiently. By using Git together with GitHub, everyone in the team can work on their own branches. Once feature development or bug fixes are complete, they can smoothly merge their changes back into the main codebase (master branch)

2. .Code Review
   The Pull Request (PR) feature on GitHub makes code review more efficient. Developers can request that the team review changes made to the code before merging them into the main codebase. Code reviews help reduce development errors and ensure that the submitted code meets the team's standards and quality.

3. Issue Management and Bug Tracking
   GitHub Issues helps track bugs, new features, or problems in the code. Developers can create an issue to report bugs or new features that need to be developed. Teams can use issues to track the status of tasks in an organized manner.

4. Continuous Integration (CI) Support
   GitHub can integrate with Continuous Integration (CI) tools such as GitHub Actions or Travis CI, which automate testing and make it faster and easier. Whenever you push code to GitHub, the CI system will automatically test the code, ensuring that no bugs are introduced and that the code behaves as expected.

5. Change History Logging
   GitHub logs the history of changes to the code each time a commit is made, allowing you to trace who made the changes and what was changed. This feature is useful for troubleshooting problems and identifying the cause of system errors.

How to create a new repository on GitHub

1. Go to GitHub and sign up if you don't have an account yet.
2. Create a new repository by clicking the "New" button and naming your repository.
3. Then, you can use the git clone command to copy the repository to your local machine and start developing.

How to collaborate with a team on GitHub

• Pull Requests (PRs): Used to request merging code from another branch into the main branch.
• Issues: Used to track bugs or problems that arise in the code.
• Actions: Used to set up automation, such as running tests every time new code is pushed.