Installation of Command-Line Git

This section walks you through installing Git client tools on your computer, if your computer does not already have them installed.

Instructions below vary with your operating system.

1. [YourOS=Windows]
   1. Download and Install Git for Windows, https://git-for-windows.github.io/.
      
      This installs a minimal Unix style shell (called ‘git-bash’), the basic OpenSSH tools and git.  During install select the options indicated in the sequence below:
      
   2. Note, git-bash does not install the standard Unix 'man' command which allows you to read the standard "Manual" pages for all Unix commands.   You can get some basic information for any command by typing a command name with just the parameter --help.    To find the complete man pages for a given Unix command, we suggest using https://www.gnu.org/manual/manual.en.html.    (There are ways to install the Unix man command and man pages into git-bash, but it is generally not worth the effort).
      
      Advanced Windows users might alternatively installing the much more complex "Unix emulators" https://www.cygwin.com or the comprehensive https://en.wikipedia.org/wiki/Windows_Subsystem_for_Linux.   However, the TA and professor cannot provide support for these more advanced choices.
   
   
2. [YourOS=Linux] Typically, default Linux/Unix installations include Git.  If Git is not installed, then download and install Git from http://git-scm.com/.
3. [YourOS=Mac]   Download and install Git from http://git-scm.com/.

If Unix style command-line shells are new for you, read the introduction at [WART2021] .  Linux and MacOS have a Unix style shell (bash or otherwise) built-in.

[Optional] Installation and Setup of Git GUI’s

Generally, the Git instructions in this document and any Git instructions given in this course will be given using Git command-line example code.  But many GUI Git tools are available as well. Use of GUI Git tools is optional.

1. [YourOS=Window]
   Download and install TortoiseGit from https://tortoisegit.org/
2. [YourOS=Mac/Linux]
   Various Git GUIs are found here http://git-scm.com/downloads/guis. 

initial refspec: main vs master

cci-git.uncc.edu URL List

Git Authentication Protocols

Basic Git Operations

1. How to Create New Remote Repository:
   Instructions below vary based on your server.
   1. [YourServer=cci-git]
      1. Login to the cci-git Web Server (See 7.1 cci-git Server URL)
      2. Create a new project by making the selections shown in the screen capture below.   In screen captures below whenever you must select multiple buttons, each button press is labeled with a number indicating the sequence in which you should make the selections.
         

         

         

      3. Set up a new project and repo:
           
         Note, in GitLab each repo has an Owner.    The Owner can invite other GitLab users as Members to that repo.   The Owner controls what access permissions each Member has.  For this class, you must be the Owner of all your repo's.   You will additionally invite the TAs and professor as Members of each repo so they can access your repos.
         3/13/2023: Elaborated details on "Owner" vs "Member"
         Create your new project selecting the settings shown below.    For action #2 select your user name to make you the Owner of the project.   (Do not select the group "itcs-3120-wartell/students/FirstName LastName" for action #2).
         
         

         

      4. Open the Members dialog by making the menu selections below.
         

         

      5.  Next, you will add permission for the professor and TAs to access your project.  Perform the actions indicated in the following screen captures.
         
         1. Select Invite Group: 2/13/2023: Updated course workflow to use private student groups. This simplifies student repo management and grading.

            

         2. Add Your Private Student Group: 2/13/2023: Updated course workflow to use private student groups. This simplifies student repo management and grading.
            Each student in this course has a private group accessible only to the student (yourself) and the course grading staff (professor, TA's, graders, etc.).    The group name will be similar to "itcs-3120-wartell/students/FirstName LastName" where FirstName and LastName are your name as recorded in your GitLab profile.   (If a your GitLab profile does not record a name, then your private group name will be "itcs-3120-wartell/students/uncc_user_id").
            
            Invite your private group to your repo, using the dialog below and give that group "Reporter" access.
            

            

      6. Finally, you should disable the Auto DevOps feature for your project.   (Otherwise gitlab is likely to generate extra error messages later on when you perform git command line operations).
         
         
         1. Open the  Settings and CI/CD.

            

         2. . Under Auto DevOps click Open the Expand.

            

         3. Uncheck the checkbox, Default to AutoDevOps Pipeline, and click Save Changes.

            

         
         
         
      7. Finally, you should verify that you can clone your created repository.   To determine the URL make the selection below:

         

         Then clone the repo:

         ▽	~/ITCS_3120/ mkdir verify; cd verify ~/ITCS_3120/verify git clone URL of of the Repo Cloning into 'my-first-repo'... warning: You appear to have cloned an empty repository. Checking connectivity... done. $ ls my-first-repo

2. How to Push to New Remote Repository:
   To push files to a new empty, remote repository, such as one created in following Item #2 (above) do as follows. Assume the remote is called Project_Example.git:
   
   1. [YourServer=cci-git]
      1. Option I: git clone:  
         If you have not already created files in a local directory that you want to import, performing the following:
         

         ▽

         $ git clone https://cci-git.uncc.edu/ your_uncc_user_id/Project_Example.git Cloning into 'Project_Example'... warning: You appear to have cloned an empty repository. Checking connectivity... done. $ cd Project_Example [… create, add and commit files… below is just an example] $ touch README.md $ git add README.md $ git commit -m "add README" [ main (root-commit) dd8e1a0] add README  1 file changed, 0 insertions(+), 0 deletions(-)  create mode 100644 README.md      $ git push -u origin main $ git push -u origin main Counting objects: 3, done. Writing objects: 100% (3/3), 219 bytes | 0 bytes/s, done. Total 3 (delta 0), reused 0 (delta 0) To git@cci-git.uncc.edu:your_user_id/Project_Example.git

         
         
         
      2. Option II:   git init:
         If you already created files in a local directory (call it Project_Example and that local directory is not already a local Git repo, perform the following: (1) initialize that directory as a local Git repo and (2) push it the remote Git repo:
         

         ▽

         $ cd Project_Example $ git init Initialized empty Git repository in Project_Example/.git/ $ git remote add origin https://cci-git.uncc.edu/your_user_id/Project_Example.git $ git add -A $ git commit –m "-initial import" $ git push -u origin main Counting objects: 3, done. Writing objects: 100% (3/3), 219 bytes | 0 bytes/s, done. Total 3 (delta 0), reused 0 (delta 0) To git@cci-git.uncc.edu:your_user_id/Project_Example.git

3. Deleting a remote repo:
   1. [YourServer=cci-git] See https://cci-git.uncc.edu/help
      

Submitting Class Assignments

Submit all your assignments by using Git add, commit and push to upload your code to your Git repository subdirectory.

Keep the repository clean!!!

It is standard practice when using version control software to not commit intermediate or output files generated by the compiler into the repository.  Intermediate or output compilation files are all regenerated when someone else checkout’s the source code and recompiles it. Like all compilers MSVS 20xx C++ compiler generates lots of these (*.ncb, *.ilk, *.exe, *.obj, etc.).  

Rule: Do not commit such intermediate files to your Git repository!

 Fortunately, you can automate this process using the .gitignore mechanism (see [Chacon2016]).

Reasoning:

Adding intermediate auto-generated files to the repository is wasteful, messy and can create subtle problems.  Many intermediate files will create compilation problems if they are copied between different computers. Putting them in the repository is equivalent to such copying. 

By convention, the following files should be put in the repository depending on your programming language and development tools.

Verify Your Remote Repository

The TA only sees your remote Git server repo’s.

Rule:  Always make sure your assignment appears as you expect in the remote repo (on the Git server).

The Ultimate Verification:

The ultimate way to verify the remote repo contains the files you think it does is to clone it into to another directory and check that second cloned copy for completeness.   You should do this when you are completely done with your assignment.

 Some Safety Checks:

Performing The Ultimate Verification while you are developing code is tedious. During software development the following are good practices to keep track of your commit’s and push’s.

• git-status
  
  Good Result:
  

  ▽	lucretius@CCIWD-435B-1 ~/ITCS_4120/Project_42 $ git status # On branch main nothing to commit, working directory clean

  
  The above indicates everything is good.   You have no file changes that have not been committed to the local repo and no local repo commits that have not been pushed to the remote repo.
  
  Maybe Bad:
  If you get messages like:

  ▽	lucretius@CCIWD-435B-1 ~/ITCS_4120/Project_42 $ git status # On branch main  # Untracked files: #   (use "git add <file>..." to include in what will be committed) # #       junk_or_important.txt

  
  then you have untracked files (but you have push’ed all your commits).  This maybe ok as along as these files aren’t files that belong in a repo (such as temporary files).  You might consider adding to the .gitignore file (see [Chacon2016]).
  
  Bad:
  If you get a message like:
  

  ▽	lucretius@CCIWD-435B-1 ~/ITCS_4120/Project_42 $ git status # On branch main # Your branch is ahead of 'origin/main ' by 1 commit. #   (use "git push" to publish your local commits) # nothing to commit, working directory clean then

  then you have not pushed all your latest changes to the remote repo. Do a git-push before the final assignment deadline. 
  
  
• [Optional] TortoiseGit – Optionally, another good way to check with the TortoiseGit shell extension is using Check for Modifications. This will show you whether you have any changes not commited to the local repo (but make sure to check the box, Show Unversioned Files).   Below we see one file is untracked.
  

  

  
  However, Check for Modifications will not tell you whether you have pushed all your commits to the remote repo.  
  
  For that use the TortoiseGit shell extension and select Git Sync. The following Git Sync dialog box would indicate your local repo has committed changes that you have not pushed to the server remote repo:

  

  
  

However, Git Sync does not show you if you have changes to local files that you have not commited to the local repo!