Installing Git on Windows: a Step-by-Step Guide

GitHub Copilot is a tool that helps developers write code faster and more efficiently by providing suggestions and even entire blocks of code based on comments, variable names, function names, and more. GitHub Copilot saves time when writing standard code structures and algorithms. It is helpful for beginners just learning to develop in a new language and for experienced developers who want to avoid manually writing repetitive functions and structures. GitHub Copilot can be integrated into various development environments, including: Visual Studio Neovim VS Code JetBrains IDEs It also supports a wide range of programming languages, such as: Python JavaScript Go Java C# TypeScript C++ Ruby Rust Shell script Kotlin Swift GitHub Copilot is compatible with popular frameworks and libraries like React, AngularJS, VueJS, Spring, Django, Ruby on Rails, and more. In this tutorial, we’ll explain how to use GitHub Copilot when developing in Python and how it can help improve coding efficiency. Key Features of GitHub Copilot Autocomplete – Provides real-time code suggestions and autocompletion. Code Prediction – Predicts the next steps in your code and offers options to complete structures. Code Search – Helps find relevant code within a project using keywords or code snippets. Code Refactoring – Assists in optimizing and modifying existing code with refactoring features. GitHub Copilot is currently available as a subscription service for $10 monthly. How GitHub Copilot Works GitHub Copilot provides suggestions and autocomplete features based on user comments written in natural language and existing code. To achieve this, GitHub trained Copilot using publicly available repositories hosted on its platform. The effectiveness of Copilot depends on the availability of public repositories in a given programming language. It works well with popular languages like Python and offers reliable suggestions. However, for less common languages, its performance may be weaker, providing fewer and less accurate recommendations. Integrating GitHub Copilot with PyCharm PyCharm, a JetBrains IDE, supports GitHub Copilot. To integrate it into your project, follow these steps: Visit github.com/features/copilot and click Get started for free. Log in to GitHub or create an account.  Now, you can install the GitHub Copilot plugin in PyCharm: Open PyCharm. Go to File > Settings. Navigate to Plugins and search for GitHub Copilot. Click Install to add the plugin. After installation, open the Tools menu, find GitHub Copilot and click Login to GitHub. A window will appear with an authorization link and a special code. Follow the link, enter the code, and confirm authorization. Now, GitHub Copilot is fully integrated into your PyCharm project. How to Use GitHub Copilot Let's write a simple function to verify that we have successfully installed the GitHub Copilot plugin. For example, start typing a function to add two numbers, like: def add(a, b): As you begin typing, Copilot will suggest completing the function: Suggested code appears in gray and italicized text. To accept a suggestion, press Tab. To reject a suggestion, press Esc. Useful GitHub Copilot Shortcuts Action Windows Mac Activate inline suggestions Alt+\ Option+\ View next suggestion Alt+] Option+] View previous suggestion Alt+[ Option+[ Accept suggestion Tab Tab Reject suggestion Esc Esc Open all suggestions in a new window Ctrl+Enter Ctrl+Enter Using Copilot with Comments GitHub Copilot doesn’t just rely on function names—it also generates code based on comments. For example, if you write a function for matrix multiplication with a descriptive comment: def multiply_matrices(A, B): # Multiply matrix A and B and return the result Copilot may suggest the following: def multiply_matrices(A, B): # Multiply matrix A and B and return the result rows1 = len(A) cols1 = len(A[0]) rows2 = len(B) cols2 = len(B[0]) if cols1 != rows2: raise ValueError("The number of columns in the first matrix must be equal to the number of rows in the second matrix") result = [[0 for j in range(cols2)] for i in range(rows1)] for i in range(rows1): for j in range(cols2): for k in range(cols1): result[i][j] += A[i][k] * B[k][j] return result To verify that this function works correctly, let’s use the NumPy library: import numpy as np matrix1 = [[15,24],[12,44]] matrix2 = [[112, 22],[55,90]] m1 = np.array([[15,24],[12,44]]) m2 = np.array([[112, 22],[55,90]]) print(multiply_matrices(matrix1, matrix2),'\n') print(np.dot(m1, m2)) Output: [[3000, 2490], [3764, 4224]] [[3000 2490] [3764 4224]] As you can see, the function Copilot correctly performs matrix multiplication. Cons of Using GitHub Copilot GitHub Copilot is a very useful tool, but it has some drawbacks. Copilot Doesn't Test Its Code The code suggested by Copilot may contain errors. It does not perform self-checks, meaning developers must test the generated code themselves. Additionally, Copilot doesn’t always produce optimized code, both in terms of efficiency and structure. In summary, all Copilot-generated code must be reviewed and tested. Conflicts with IDEs Modern Integrated Development Environments (IDEs) do more than just provide a space for writing and debugging code—they also offer built-in suggestions. For example, when using a built-in function in PyCharm, the IDE provides information about its attributes. At the same time, Copilot might suggest something different, which can be confusing for the developer. Potential Copyright Issues This is a controversial aspect of using Copilot in commercial development. Since Copilot was trained on public repositories, it could theoretically suggest licensed code. This raises concerns about intellectual property rights when using Copilot-generated code in proprietary projects. Negative Impact on Developer Skills Copilot doesn’t teach developers how to write code—it writes it for them. For junior developers, it’s important to gain hands-on experience by implementing common functions and algorithms manually. Over-reliance on Copilot might slow down skill development. Conclusion GitHub Copilot is a useful tool for handling repetitive coding tasks. According to GitHub’s own research: 74% of developers reported focusing on more enjoyable aspects of their work, 88% felt more productive, 96% completed repetitive tasks faster. Copilot should be seen as an assistant—someone you can delegate tasks to while focusing on more important and complex problems. However, developers must carefully review all code generated by Copilot to ensure quality and correctness. 

Git is a distributed version control system developed by Linus Torvalds. It has become the standard in software development due to its efficiency and flexibility. During the development process, there are situations when you need to urgently switch to another branch using the checkout command and make changes related to a different task. However, the current changes may not be ready for a commit yet, and you don’t want to lose them. In such situations, the git stash command comes to the rescue. This tool is indispensable, allowing you to safely store current changes for a while and then return to them without disrupting the integrity of the repository. Let’s explore how to use git stash in development. Basics of git stash Let's think about how we normally work with the codebase and Git. We create something (a function or a small module), then run git add, followed by git commit and git push. Great; we have finished the task and can move on to the next one. But what if the context changes, and you need to switch urgently? You may not have finished writing the module yet, but you must complete another task now. You don’t want to leave the commit unfinished. This is where git stash comes in. So, what does it do? The process of saving temporary changes consists of two stages: stash: We save the changes to a special storage. You can also add a comment for them. pop or apply: We bring the changes back into our working directory. Preparation The version control system must track changes you are going to stash. You can add files to the tracked list using the command: git add . Creating a Stash To create a stash, use the following command: git stash Output: Saved working directory and index state WIP on master: 099797d start By default, the stash name contains the abbreviation “WIP” (Work In Progress) and the branch name. If you want to specify a comment, you can use the following commands: git stash push or git stash save: git stash push -m "<your comment>" The result will be: Saved working directory and index state On master: <your comment> The same result will occur with this command: git stash save "<your comment>" However, this command is considered deprecated — you can check the documentation for more details. Retrieving Changes Now, let’s return to the original task. We need to bring back the hidden changes. Use the command: git stash pop The output will tell you that the changes have been applied to the current working area and can now be used. It will also indicate that all data has been removed from the special temporary storage. If you need to apply the changes without removing them from the stash, use the command: git stash apply Additional Commands and Parameters List All Stashes To view the list of changes that have been stashed in the repository, you can use the command: git stash list Example output: stash@{0}: On master: User Story #2010stash@{1}: WIP on master: 099797d start Applying Specific Changes by Index To apply a specific change, you can use the pop command with the stash index: git stash pop 'stash@{1}' Example output: no changes added to commit (use "git add" and/or "git commit -a")Dropped stash@{1} (563f9c20ab12525795911fbed0c4ebf4a1298b4e) Additional Parameters for the git stash Command If you need to stash changes while keeping them in the working directory, use the --keep-index flag. In this case, files added to the tracked list using the git add command will remain: git stash --keep-index Output: Saved working directory and index state WIP on master: 099797d start If you call git status after this, the modified files will still be there: On branch main Changes to be committed: (use "git restore --staged <file>..." to unstage) modified: GitStash/Program.cs modified: GitStash/SomeModule.cs If you need to add files that git does not track yet, use the --include-untracked flag: git stash --include-untracked When you retrieve changes using pop, you will see a message about the presence of untracked files: ... Untracked files: (use "git add <file>..." to include in what will be committed) GitStash/NewClass.cs ... Sometimes it may be convenient to split the uncommitted changes into separate stashes. In this case, the git stash -p command will help: git stash -p For each change, hiding will be done separately, with a prompt for confirmation. Here are the options for confirmation: ? — to show all options y — to stash the change n — to not stash this part of the change q — to stash all selected parts and finish Viewing Specific Changes in a Stash The show command displays information about the changes in a specific stash, for example: git stash show GitStash/Program.cs    | 3 ++- GitStash/SomeModule.cs | 7 +++++- 2 files changed, 8 insertions(+), 2 deletions(-) You can also specify the index of a specific stash: git stash show 'stash@{1}' Example output: GitStash/SomeModule.cs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) Clearing Changes from a Stash To remove a specific stash, you can use the drop command. If you don't specify an index, it will remove the most recent set of stashed changes: git stash drop Or: git stash drop 'stash@{1}' Output: Dropped stash@{1} (bedb3c2add59a3f203e2367602328dca8b33b6e9) To completely clear the stash storage, you can use the command: git stash clear Creating a New Branch from a Stash To create a new branch based on stashed changes, use the following command: git stash branch <branch name> <stash index> Or simply: git stash branch <branch name> For example: git stash branch some-feature stash@{2} How It Works The set of changes we hide in the stash is actually a series of commits. Running this command creates two or three commits: The commit stash@{0} contains the stashed files. The parent commit is the HEAD commit in Git's current working directory. If we run the command with the --keep-untracked flag, a separate commit will be created for the untracked files. What happens when you run the pop command? The stashed changes are returned to the repository's working copy and indexed by Git. Other stashes are shifted. The extracted commits are deleted. The .git/refs/stash file contains a reference to the last commit for the stash. cat .\.git\refs\stash Output: 07ea0c456356e883610f43c20d9cb298ff2ebb8a Use Cases Let's look at some common use cases for this mechanism in practice: Backup Before Merge or Rebase The merge / rebase commands are necessary when working with multiple branches. However, conflicts often arise that can cause important changes in the current working directory to be lost. Before performing a merge, ensure that the current branch is up to date, i.e., it doesn't contain unsaved changes. If you have unsaved changes that should be preserved before merging, run this command: git stash push -m "Backup before branch merge" Proceed with the merge, running merge or rebase. Conflicts may arise between the changes in the current branch and the changes in the other branch when executing these commands. You can resolve conflicts using either IDE tools or Git. After successfully completing the merge or rebase, you can restore the changes to the current working directory using apply or pop. Non-Debugging Changes The stash mechanism can also be helpful for working with non-debugging changes, such as temporary fixes, comments, or code formatting. Instead of committing these changes to the current commit, you can use git stash to save them temporarily. This helps in creating clean commits and improves the structure of the Git history. Effective Project Configuration Management Another scenario for using git stash is effectively managing project configurations. Depending on the task or environment you are working in, you might need to modify configuration files, but permanently saving them might not be practical. Saving different configurations Suppose there is a configuration file that defines the parameters for your application (e.g., config.json). You need several versions of this file for different use cases (e.g., local development, testing, and production). You can use the stash to save these configurations. # Saving the configuration for local development git stash save "Local configuration" # Saving the configuration for testing git stash save "Testing configuration" # Saving the configuration for the production environment git stash save "Production configuration" Applying configurations as needed When you need to switch between different configurations, simply use git stash apply or git stash pop to apply the corresponding stash: # Applying the configuration for testinggit stash apply stash@{1} Tips for Effective Using git stash Use clear stash descriptions. The default messages created for stashes usually don’t convey the essence of the changes — they’re simply an abbreviation like WIP, a commit ID, and the branch name: WIP on master: 099797d start Use the push or save commands to add descriptive messages, for example: git stash save "test configuration" Or: git stash push -m "Started working on issue #11 - added contract for the module" Check and clean your stashes. During long-term project development, you may accumulate a large number of changes that are no longer relevant. Use the list and show commands to view the changes and git stash drop to remove obsolete stashes. This mechanism is not intended for long-term data or change storage. Use stash with other commands. You can combine git stash with other commands, such as git stash branch, to create new branches, or with the rebase and merge commands to back up local changes. Conclusion In this article, we’ve explored the git stash command and its use cases. git stash is a powerful tool that can significantly simplify managing changes in your repository and improve your workflow. We’ve examined both basic and advanced scenarios for using this tool, including creating, applying, extracting, and managing stash entries.

In most cases, working with the Git version control system is done locally. However, you sometimes need to sync with a remote repository to update your local storage. Git provides two key commands for this: git fetch and git pull. A remote repository is a storage location hosted on the network, usually on platforms like GitHub, GitLab, or Bitbucket. These services allow developers to collaborate on projects, make changes, and synchronize code between local and remote versions. Both commands are used to download updates from a remote repository, but they work differently. In this guide, we will explore their practical applications and highlight their key differences. Prerequisites Since this article covers practical usage, you’ll need the following: A server, virtual machine, or computer with any operating system where Git can be installed. A Git client pre-installed. An account on GitHub. The git fetch Command Let’s start with what git fetch does. git fetch is used to grab the latest data from a remote repository and put it into your local storage without modifying any files in your working directory. Instead, it updates the so-called remote-tracking branches, which reflect the state of the remote repository at the time the command is executed. This is how git fetch works: Establishes a connection with the remote repository. Downloads new commits, files, branches, and tags. The data is added to the local repository but not merged with the current working branch. Basic syntax of git fetch: git fetch <remote-repository-url> Useful options: git fetch --all — Downloads updates from all remote repositories linked to the local storage. git fetch --dry-run — Checks for changes before downloading without making any actual changes. git fetch --force — Forcefully updates data in the local repository, overwriting any conflicts. git fetch --tags — Downloads all tags from the remote repository. git fetch --prune — Removes references to branches that were deleted in the remote repository. The git pull Command Unlike git fetch, the git pull command downloads the latest changes from a remote repository and automatically merges them into your current local branch. Essentially, executing git pull involves two operations: git fetch — Downloads new data. git merge — Merges the downloaded changes with the local branch. This is how git pull works: Establishes a connection with the remote repository. Downloads the latest data, including commits, files, tags, and branches. The downloaded changes are merged into the current local branch. Basic syntax of git pull: git pull Useful options: git pull [remote-repository] [branch] — Downloads changes only from the specified repository and branch. For example, git pull origin main updates the local main branch from the remote repository origin. git pull --rebase — Instead of performing a standard merge, this applies the changes on top of the local commits, helping to avoid unnecessary merge commits. Comparison: git fetch vs git pull To better understand the differences between these two commands, here's a comparison table: Criterion git fetch git pull Action Only downloads changes Downloads and merges changes Impact on Local Repository Does not modify files or branches Modifies the current branch and files Safety Safe, as it does not cause conflicts May cause conflicts during merging Previewing Changes Allows reviewing and analyzing changes before merging Automatically integrates changes without preview Flexibility Requires manual merging Merges automatically When to Use Git Fetch vs. Git Pull When to Use git fetch Before Making Changes to the Source Code: git fetch allows you to see which commits have been made on the remote branch and evaluate the changes before merging them into your local branch. When Working in a Team: If multiple developers are working on the project, git fetch helps you stay up-to-date with their work and minimize potential conflicts before integrating changes. To Retrieve New Branches and Tags: If a new branch or tag has been added to the remote repository, git fetch will download them without automatically switching to them. When to Use git pull To Get the Latest Changes: In team projects, members regularly make updates. To bring all the latest changes into your local repository, use git pull. For Quick Branch Updates: If you need to quickly update your branch without analyzing the changes beforehand, using git pull is the easiest approach. Using Git Fetch and Git Pull in Practice Creating a Repository on GitHub Log in to GitHub. If you don’t have an account, you can register a new one. Click on the New button to create a new repository. Provide a name for the repository and select the Public option. Click on your profile picture in the upper-right corner and select Settings from the drop-down menu. Scroll down to Developer settings on the left. Expand Personal access tokens and go to Tokens (classic). Click on Generate new token, then Generate new token (classic). If prompted, authenticate using the mobile app. Give the token a name and set an expiration date. Under permissions, select the repo category. Click on Generate token to create the token. Copy and save the token, as it won’t be shown again. Creating a Local Repository Go to the server where Git is installed. Create a new directory to store your files and navigate to it: mkdir test-git-fetch-pull && cd test-git-fetch-pull Initialize a new Git repository: git init Create a new file and add a line to it: echo "Test git fetch and pull commands!" > newfile1.txt Add the file to the staging area: git add newfile1.txt Create an initial commit: git commit -m "Initial commit" If you see the message: Author identity unknown*** Please tell me who you are You need to set your name and email using: git config --global user.email "example@example.com"git config --global user.name "<name>" Then, repeat the commit command: git commit -m "Initial commit" Add the remote repository. Use the command from the main page of your newly created repository on GitHub. For example: git remote add origin https://github.com/<github-account>/test-git-fetch-pull.git Push changes to the remote repository: git push -u origin main When prompted for Username for 'https://github.com', enter your GitHub username. When prompted for Password for 'https://<username>@github.com', enter the previously generated token. Go back to the GitHub web interface and check that the file is present in the repository. Working with Changes Now, let’s simulate changes in the remote repository. Open the file for editing directly in the GitHub interface. Add a new line at the end of the file. Click the Commit changes button on the right. Go back to the server where your local repository is located and run: git fetch origin Now, check the file content: cat newfile1.txt You'll notice that git fetch downloaded the changes from the remote repository, but the local branch (main) and the file remained unchanged. However, the changes can be seen in the remote branch: git log origin/main To see exactly what changes were made in the remote repository after running git fetch, use: git diff main origin/main Now, let's pull the changes into the local branch: git pull origin main Display the file content again: cat newfile1.txt Now, the changes made in the GitHub interface are applied to the local copy of the repository. Resolving Conflicts When Using git pull When using git pull, you may encounter conflicts. In Git terminology, a conflict occurs when the system cannot automatically merge changes from two different sources — the local and remote repositories. To learn how to resolve conflicts, let's go through a practical example. We'll simulate the following situation: We have a repository containing a file named future-file1.txt. Two developers (Developer 1 and Developer 2) are working on the same branch (main). Preparing the Repository Create a new repository in GitHub. Follow the same steps as in the previous chapter to create a new repository. On the server, create a new directory and navigate to it: mkdir git-conflicts && cd git-conflicts Initialize the Git repository: git init Create a new file: touch future-file1.txt Write the first line into the file: echo "First message" > future-file1.txt Stage the file: git add future-file1.txt Commit the changes: git commit -m "Initial commit" Connect the local repository to GitHub. Replace the URL with the one for your GitHub repository: git remote add origin https://github.com/<github-account>/git-conflicts.git Push changes to the remote repository: git push -u origin main You'll be prompted to enter your GitHub username and personal access token. Making Changes as Developer 2 Now, let's simulate the scenario from the perspective of the second developer (Developer 2). On another machine or in a new directory on the same server, run: git clone https://github.com/<github-account>/git-conflicts.git At this point, both developers have an up-to-date copy of the repository. Making Changes as Developer 1 Switch back to the local repository used by Developer 1: Add a new line by overwriting the content of future-file1.txt: echo "Second message" > future-file1.txt Stage the changes: git add future-file1.txt Commit the changes: git commit -m "Second commit" Push changes to the remote repository: git push origin main Conflict At this point, Developer 1's changes are in the remote repository. However, Developer 2 still has the old version of future-file1.txt. Navigate to the project folder that was previously cloned by Developer 2. Overwrite the file by adding a new message: echo "Third message" > future-file1.txt Stage the file: git add future-file1.txt Commit the changes: git commit -m "Third commit" Pull the latest changes from the remote repository: git pull origin main As you can see, Git has detected a conflict: When viewing the file, you will notice a conflict block in the file, marking the conflicting changes. Resolving the Conflict To resolve the conflict, you need to delete the lines starting with <<<<<<< and ending with >>>>>>>. Then, you can decide whether to keep only the local changes or to retain the old ones and add the new ones. As an example, let's keep the changes from both developers: Developer 1's message ("Second message") Developer 2's message ("Third message") After editing the file, stage it again: git add future-file1.txt Commit the resolved conflict: git commit -m "Resolved conflict" Push the changes to the remote repository: git push origin main You will need to enter your username and token to push the changes. Go to the GitHub interface and verify the result. Conclusion The git fetch and git pull commands are used to retrieve the latest changes from a remote repository into your local repository, but they do so differently. git fetch allows you to safely fetch updates and analyze the changes made by others without affecting your current working copy. This is especially useful for avoiding unexpected conflicts, as no changes are applied automatically. git pull fetches the data and immediately merges it into the local repository. This process requires caution. If conflicts occur, you will need to resolve them manually. The choice between these commands depends on your goals: If you want to check changes first, use git fetch. If you need to quickly update the code, use git pull, but be aware of the possible conflicts.