Version control, also known as revision control and source control, is the management of changes to information. A version control system keeps track of software versions throughout development. A distributed version control system allows many developers to work on a given project without requiring that they maintain a connection to a common network.

We use git for distributed LabVIEW code version control. Our code repositories are managed externally on a GitLab server and internally on a Git server.

In order to be able to work on our LabVIEW code you need to follow the steps described here.

Go to gitlab.com/users/sign_up and create a free account. Then let us know about your username so we can grant you access to our repositories.

Install git on your development machine.

Git itself is a collection of tools that are operated from the command line (or bash). However, there are GUI clients available for all major operating systems:

• Tower (the tool of our choice, for Mac OS X and Windows)
• SourceTree (a free alternative to the Tower app, for Windows and Mac)

Git checks 4 places for a configuration file, cascading settings in the following order:

• Your machine's system .gitconfig file.
• Your user .gitconfig file located at ~/.gitconfig.
• A second user-specific configuration file located at $XDG_CONFIG_HOME/git/config or $HOME/.config/git/config.
• The local repo's config file .git/config.

If you haven't been asked for your name and your email address during installation, you can manually set this information:

  git config --global user.name "Your Name"
  git config --global user.email "your@email.address"

  [user]
  	name = Your Name
  	email = your@email.address
  [core]
  	excludesfile = /some/path/to/.gitignore_global
  	filemode = false

The exludesfile mentioned in the .gitconfig file (the global .gitignore file) defines which files to ignore (exclude from versioning) for all repositories on the computer its stored on. You can set the path of the global exludesfile to the actual user's home directory with

  git config --global core.excludesfile '~/.gitignore'

Each repository and each directory in it can have its own .gitignore file.

  *~ 
  ._* 
  .DS_Store
  Thumbs.db
  *.aliases
  *.lvlps

If you're using msysgit on Windows:

• the machine's system .gitconfig file resides at %PROGRAMFILES(X86)%\Git\etc\gitconfig.
• your user ~/.gitconfig file resides at your %HOMEPATH%

Use echo %PROGRAMFILES(X86)% and echo %HOMEPATH% from a Windows command prompt to find the specific locations.

Set the global .gitignore file location to C:/users/{myusername}/.gitignore:

  git config --global core.excludesfile "%USERPROFILE%\.gitignore"

The above command will only set the location of the ignore file that git will use. The file has to still be manually created in that location and populated with the ignore list.

Open up My Computer → Advanced System Settings → Environment Variables. Then:

1. Add the git binary path (eg C:\Program Files (X86)\Git\bin) to the PATH environment variable
2. Add msys to the TERM environment variable

If your repository is on a filesystem whose executable bits are unreliable (like FAT), git should be configured to ignore differences in file modes recorded in the index and the file mode on the filesystem if they differ only on executable bit:

  git config --local core.filemode false

and/or

  git config --global core.filemode false

To establish a secure connection between your computer and GitLab via Secure Shell (SSH) you will need to create and install SSH keys. The private key resides on your computer, the public key is stored at the GitLab server.

• On a Mac, follow the steps in the GitLab SSH keys help
• On Windows, see the beanstalk article mentioned above

Add your key by navigating to the 'SSH Keys' section in your user profile, selecting 'Add SSH Key' and copy-pasting the public key to the 'key' field. Please copy the complete key (a long string starting with ssh- and ending with the comment you specified, usually your email address).

For some setups, the SSL certificate verification will fail. Error messages might be:

  error: SSL certificate problem, verify that the CA cert is OK. Details:
  error:14090086:SSL routines:SSL3_GET_SERVER_CERTIFICATE:certificate verify failed while accessing (repo)

or

  Cloning into 'c:\repo-path'...
  ssh_exchange_identification: Connection closed by remote host
  fatal: Could not read from remote repository

If it is acceptable to turn off the SSL validation instead of actually solving the issue this will turn off validation for the current repo

  git config --local http.sslVerify false

If you would rather have this as a default behaviour for git then the following will do it for all repos

  git global --local http.sslVerify false

and for those that would rather add to the .git/config file directly the entry looks like

  [http]
      sslVerify = false

We created a test repository to let you check your installation and make your first steps.

To get the code you need to clone a remote repository:

  git clone git@gitlab.com:hampel-soft/hse/hampelsoft-test.git

Beware: SSH clients use the known_hosts file to authenticate the server, to check that it isn't connecting to an impersonator. The first time you connect to a new server, you have to acknowledge the authenticity of the server by accepting the ECDSA key fingerprint. Some GUI clients hide the appropriate message, so if you get permission errors, try cloning from the command line.

To propose files for version controlling (to make git work with your files) you need to stage the files:

  git add README.txt

To actually add new or changed files to the repository, you need to commit them:

  git commit -m "first commit"

To send your changes to the central, remote repository, you need to push your local repository:

  git push -u origin master

Please read Version Numbers for more information on our version number formats and policy.

Git does not give perfect integer revision numbers that increment on each commit. Instead, git hashes the commit data and uses that as a unique identifier of the commit. That means one commit could be 8d844d8d… and the next f1728db4…, which is incomprehensible AND unusable as (part of) our version numbering convention.

However, git allows you to create descriptive labels for marking specific points in history as being important, i.e. creating pointers to specific commits. These pointers are called tags. Typically, tagging is used for marking release points (v1.2.3, and so on), and that's exactly what we do, as well.

Read the Git Documentation for detailed info on how to use tags, and the Tower Documentation on how to create tags with Tower.

• Official Git Tutorial
• GitLab Documentation
• Simple git how-to in german

• internal: Source Code Control