Git and GitHub are indispensable tools in the software development process. Whether you are a new programmer or an experienced software engineer, using Git and GitHub effectively will save you time and improve the quality of your products. Here are 5 tips to help you work faster and more freely with Git and GitHub.
Part 1 – Understanding and Using Common Git Commands Widely
To work effectively with Git, the first thing you need to do is get familiar with the basic commands. Here are some important Git commands and how to use them.
git clone <repository>
This command helps you clone a repository from a source (usually GitHub, GitLab, Bitbucket, etc.) to your computer.
git status
This command displays the current state of the working directory and staging area. It will show you changed files, untracked files, and staged changes.
git add <file>
To track changes to a file, use the git add command. This applies not only to new files, but also to existing files that you have modified.
- To stage all files:
git commit -m “message”
The git commit command saves a “snapshot” of your changes, along with a commit message to explain those changes.
git push
Once the changes have been committed, you can push them to the remote repository using the git push command.
git pull
The git pull command lets you update new changes from a remote repository to your computer. This includes fetching the changes and merging them into the current branch.
Mastering these commands is fundamental to working effectively with Git. If you get familiar with them, managing your code projects will become easier and faster.
Part 2 – Creating Alias for Complex Commands
Using Git commands can become complex and cumbersome, especially when you have to repeat long strings of commands over and over again. To reduce this complexity and speed up your workflow, you can use an “alias” – an abbreviation or shorthand phrase – to represent a longer string of commands.
How to create Alias in Git
Create Local Alias
You can create a local alias (applicable only to a specific repository) by running the following command in the terminal:
After running this command, you can use git st instead of git status.
Create Global Alias
If you want to create an alias that can be used in every repository on your machine, add the –global flag when running the command:
Add Alias to configuration file
Alternatively, you can also add an alias to your .gitconfig configuration file, which is usually located in your home directory (~).
To add an alias, open this file with a text editor and add the following to the [alias] section:
Example of Complex Alias
Aliases aren’t just limited to shortening a simple command. You can also create aliases for complex command strings. For example:
This alias (ac) will add all changed files to the staging area and commit immediately. To use it, just type git ac.
Why use Alias?
- Save time: No need to type the entire command string.
- Easy to remember: Create memorable alias names that help you quickly recall commands.
- Optimized workflow: Multiple commands can be combined into one alias, helping to automate complex tasks.
Thus, creating aliases in Git not only helps you work faster and more efficiently, but also helps optimize your workflow.
Part 3 – Using visual tools
While using the command line is a powerful way to interact with Git, it can sometimes become complex and difficult to follow. This is especially true when you are reviewing changes in a large project with many branches and commits. That’s where using a graphical user interface (GUI) when working with Git can be very helpful.
Benefits of using visual tools
- Visual display: These tools often display branches and commit history visually, making it easier to follow and understand.
- Convenient for code review: Some tools have a code comparison feature, showing the differences between commits or branches clearly.
- Integrate with extended functionality: The tool can integrate with other services like GitHub, GitLab, and Bitbucket, helping you manage issues, pull requests, and even CI/CD right within its interface.
Popular tools
- Sourcetree: This is a free and intuitive tool that supports both Git and Mercurial. Sourcetree also supports features like staging, commits, branching, and merging right in the interface.
- GitHub Desktop: This is the official tool from GitHub, providing an easy way to manage your GitHub repositories. It also supports reviewing and merging pull requests.
- GitKraken: This is a powerful Git GUI tool with a beautiful interface and many useful features like a task manager, integration with Trello, and GitFlow support.
How to use
- Installation: First, you need to install the tool on your computer. Usually, this process is very simple and only requires a few clicks.
- Connect to Repository: Open the tool and connect it to your Git repository. Usually, you will need to provide the path to the repository or possibly clone a new one.
- Basic operations: Visual tools often have buttons, menus, and widgets that let you perform basic Git operations (e.g. commit, push, pull) visually.
- View history and branches: Use visual features to track commit history and understand your branch structure.
Once you get used to using these visual tools, you’ll find managing and understanding your Git projects much easier and more efficient.
Part 4 – Using git stash
One of the common problems when working with Git is that you are working on a feature or bug fix and you need to switch to a different branch without committing your current changes. This is where git stash comes in handy.
Git stash basics
The git stash command helps you temporarily store uncommitted changes in a “stash”, allowing you to switch to another branch without affecting the changes you are working on.
Save temporary changes
To save all changes in the working directory and staging area, you can run:
Save temporary changes with description
If you want to add a description to the changes you are saving, use:
Show Stashes
To see a list of all stashes, use:
Reapply changes
To reapply changes from the most recent stash, run:
If you have multiple stashes and want to apply a specific stashes, you can select it by providing the stash name:
Delete Stash
To delete a specific stash after it has been applied, use:
Why use git stash?
- Flexibility in your work: git stash allows you to quickly switch between different branches without worrying about retaining the current state of your project.
- Don’t ruin your commit history: Instead of creating temporary commits just to save the state of your changes, you can use stash to save your changes temporarily.
- Reverting changes: If you realize some of the changes you made aren’t what you wanted, git stash makes it easy to revert and reapply those changes.
- Improve productivity: Sometimes, moving between tasks can disrupt your workflow. Using git stash helps you focus on the current task.
By using git stash liberally, you’ll have another powerful tool for managing your project’s state, making working with Git faster and more efficient.
Part 5 – Using GitHub Actions
If you’ve been working with GitHub, you’ve probably heard of GitHub Actions — a powerful feature that lets you automate workflows right in your GitHub repositories. Here are some details on how to use it to speed up your workflow.
GitHub Actions Basics
GitHub Actions lets you set up automation scripts using YAML files. These scripts can perform a variety of tasks, from checking in code, building and deploying apps, to automatically creating issues or even updating project boards.
Basic steps to using GitHub Actions
- Step 1: Create a Workflow File. First, in your GitHub repository, navigate to the .github/workflows folder. Create a YAML file, for example main.yml.
- Step 2: Define steps and jobs: In the YAML file, you will define the jobs and steps that GitHub Actions needs to perform. Each job can run on different operating systems and include multiple steps.
- Step 3: Trigger Workflow. You can set up workflows to run automatically when events occur, such as when a new commit is pushed to the master branch, or when a pull request is created.
- Step 4: Monitor and debug. Once the workflow runs, you can monitor the progress in the “Actions” tab of your GitHub repository. If there are errors, you can view the logs to debug.
Benefits of using GitHub Actions
- Automate complex tasks: You can automate CI/CD, testing, linting, and more.
- Deep integration with GitHub: No need for external services, everything is managed directly in GitHub.
- Highly customizable: There are tons of actions provided by the community and you can also write your own.
- Easy to manage: All settings are stored in code, making it easy to manage and track changes.
- Save time: Automating tasks through GitHub Actions can save a significant amount of time and reduce repetitive tasks.
With GitHub Actions, you have powerful tools at your fingertips to optimize your workflow, reduce complexity, and speed up your project development.
Conclusion
At ITBee Solutions , we always consider optimizing workflow and improving team performance as an important factor for sustainable development and providing effective technology solutions. The tips and technologies mentioned in this article, from using common Git commands, creating aliases, to using visual tools and GitHub Actions, not only help individual developers improve their performance but also play an important role in achieving excellence in projects at ITBee Solutions.
We believe that by implementing these methods, your team can focus more on creating quality products and services, instead of wasting time on complex source code management tasks. ITBee Solutions is always committed to providing the most optimal and advanced technology solutions, helping our customers achieve their business goals and at the same time, creating long-term values.
FOR MORE INFORMATION, PLEASE CONTACT:
Hotline: (+84) 948 810 812
Email: info@itbeesolutions.com
Website: https://itbeesolutions.vn/
Address: 21 Le Trung Nghia, Ward 12, Tan Binh District, Ho Chi Minh City
