diff --git a/development-environments/README.md b/development-environments/README.md index 63484a4..5903015 100644 --- a/development-environments/README.md +++ b/development-environments/README.md @@ -18,20 +18,23 @@ errors caused by clashing package dependencies. - [Getting Started with Conda, Virtual Environments, and Python](https://UBC-Geography.github.io/development-environments/conda-getting-started) -### Conda +### Conda and Mamba -Conda is an extremely powerful tool for both managing environments and packages. -Using `conda install` provides the ability to install a range of packages that -either aren't available or can't be installed via Python's built-in package -manager, Pip. Additionally, Conda enables you to install and manage multiple -versions of Python on a single machine using virtual environments. +`conda` and it's faster alternative, `mamba`, are extremely powerful tools for +both managing virtual environments and packages. Using `conda install` provides +the ability to install a range of packages that either aren't available or can't +be installed via Python's built-in package manager, Pip. Additionally, Conda +enables you to install and manage multiple versions of Python or a range of +other programming languages on a single machine using virtual environments. -- [conda User Guide](https://docs.conda.io/projects/conda/en/stable/user-guide/index.html) +- [Conda User Guide](https://docs.conda.io/projects/conda/en/stable/user-guide/index.html) -If you need to install Conda on your device, we suggest using the link below to -install it using the Miniconda installer. +- [Mamba User Guide](https://mamba.readthedocs.io/en/latest/user_guide/mamba.html) -- [Miniconda, a minimal installer for conda](https://docs.conda.io/en/latest/miniconda.html) +If you need to install `mamba` and `conda` on your device, we suggest using the +link below to install it using the Miniforge installer. + +- [Miniforge](https://github.com/conda-forge/miniforge) ### Python - venv and virtualenv @@ -86,21 +89,168 @@ JupyterLab, its more feature-rich successor. You can install and run JupyterLab on your local machine in two separate ways. The traditional and most flexible approach is to install JupyterLab as a Python -package using Pip or Conda and starting it from the Jupyter command line -interface. This approach uses a locally installed version of Python to start a -basic, local server on your machine and then navigates to that server through -your preferred web browser. For those who may be uncomfortable with installing -Python and/or using command line interfaces, Project Jupyter has also released a -simple-to-use desktop application, named JupyterLab Desktop. This application -comes packaged with Python and a default set of packages that are frequently -used in scientific computing. +package using `pip`, `conda`, or `mamba` and starting it from the Jupyter +command line interface. We recommend the latter using the following commands to +create a new environment and install Jupyter along with it's dependencies within +that environment. + +```bash +$ mamba create -n jupyter jupyterlab -y +``` + +Then activate the Jupyter environment and start Jupyter Lab. + +```bash +$ mamba activate jupyter +(jupyter) $ jupyter lab +``` + +This will fire up a Jupyter server and open the JupyterLab interface directly in +your web browser. - [JupyterLab Documentation](https://jupyterlab.readthedocs.io/en/latest/index.html) +For those who may be uncomfortable with installing Python and/or using command +line interfaces, Project Jupyter has also released a simple-to-use desktop +application, named JupyterLab Desktop. This application comes packaged with +Python and a default set of packages that are frequently used in scientific +computing. + - [JupyterLab Desktop - Installation](https://github.com/jupyterlab/jupyterlab-desktop#installation) - [JupyterLab Desktop User Guide](https://github.com/jupyterlab/jupyterlab-desktop/blob/master/user-guide.md) +#### Jupyter Kernels + +Jupyter uses the term kernel to refer to separate programming languages with +their own interactive shells. It's not uncommon to have multiple projects +running in different programming languages. This is where kernels can come in +handy as they enable you to have multiple, isolated computing environments +available within a single IDE. + +When you installed JupyterLab with `mamba`, it came with its own preferred +version of Python on which it is dependent. This installation of Python is +immediately added as your default Jupyter kernel. + +and for R it is `r-irkernel`. You can find a comprehensive list of packages for +various programming languages +[here](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels). + +##### Python + +You are more than welcome to start installing Python packages into the Jupyter +virtual environment to make them available to the default Python kernel and the +Jupyter notebooks that are running off that kernel, but we recommend taking the +additional step of installing another kernel that runs in a separate environment +from Jupyter. Yes, that means that you'll have at least three different +installations of Python running on your machine if you are using and that might +feel a bit redundant, but the additional isolation and flexibility will be well +worth it as they'll ensure that you can customize your Jupyter environment with +all the extensions you want alongside a Python environment that can run any +package you need on whatever Python version you want (only stable and maintained +versions please). This comes with the added benefit of being able to export and +share your conda environment and ensuring that those you share it with only +install the packages that they need to run your code. + +Open a new terminal either in JupyterLab or a shell environment with access to +`mamba`. Then create a new virtual environment with the version of Python that +you'd like to install along with `ipykernel`. + +```bash +$ mamba create -n python_env python=3.12 ipykernel -y +``` + +Next, use `ipykernel` to install the virtual environment as a Jupyter kernel. + +```bash +$ mamba run -n python_env python -m ipykernel install --user --name python_env --display-name "Python (python_env)" +``` + +Launch JupyterLab, if it isn't already running, and you should see the +python_env environment listed as a kernel in the launcher. + +##### R + +Similar to Python, you have the option of running an R kernel within the same +environment as Jupyter or from an entirely separate one. Unfortunately, setting +up an R kernel can be a little more complex, so the recommended approach is to +run your R kernels alongside Jupyter within their own separate virtual +environments. This loses some of the convenience of operating within a single +JupyterLab setup or alternatively running within an R-centered IDE, like +RStudio, but it comes with the key benefit of enabling your R code to be shared +in a larger Jupyter-based ecosystem. + +```bash +$ mamba create -n r_env r-base r-irkernel jupyter -y +$ mamba run -n r_env Rscript -e "IRkernel::installspec(name='r_env',displayname='R (r_env)')" +$ mamba run -n r_env jupyter lab +``` + +If you are keen to attempt to add an R kernel to an exiting Jupyter environment +and don't mind running into a few issues, you can try the following set of +commands. + +Create your R-based conda environment, which will be hosting the kernel, and +activate it. + +```bash +$ mamba create -n r_env r-base r-irkernel -y +$ mamba activate r_env +``` + +Then from a Bash environment copy the kernelspec directory that is included with +the r-irkernel package. This directory holds a default kernel config that is +used when installing kernels in Jupyter. + +```bash +$ cp -r $CONDA_PREFIX/lib/R/library/IRkernel/kernelspec r_env_kernel +``` + +First run one `sed` command on the Jupyter kernel config file that replaces the +command that starts the default installation of R with a command that points to +the installation of R running in your virtual environment. + +::: {.panel-tabset} + +## Windows + +Be sure to replace `` with your Windows username. + +```bash +$ sed -i 's/"R", /"C:\\\\Users\\\\\\\\miniforge3\\\\Scripts\\\\mamba.exe", "run", "-n", "r_env", "R", /' r_env_kernel/kernel.json +``` + +## Mac OS or Linux + +```bash +$ sed -i 's/"R", /"mamba", "run", "-n", "r_env", "R", /' r_env_kernel/kernel.json +``` + +::: + +Then update the display name used in the Jupyter launcher to match your +environment name. + +```bash +$ sed -i 's/"display_name":"R"/"display_name":"R (r_env)"/' r_env_kernel/kernel.json +``` + +Deactivate your environment. + +```bash +$ mamba deactivate +``` + +Finally, install the kernel into Jupyter and cleanup by deleting the temporary +kernel config directory. + +```bash +$ mamba run -n jupyter jupyter kernelspec install r_env_kernel --user +$ rm -rf r_env_kernel +``` + +When you start up JupyterLab, the new R kernel should be listed in the launcher. + #### JupyterHub The easiest way to get started with creating and editing notebooks is through a @@ -157,7 +307,17 @@ While JupyterLab excels at providing an intuitive environment for creating and editing Python-based computational notebooks, RStudio provides a similarly intuitive environment for working with the R programming language. It provides useful tools for writing R scripts, interacting with the R console, or -developing R-based computational notebooks with Quarto or R Markdown. +developing R-based computational notebooks with +[Quarto](https://quarto.org/docs/get-started/hello/rstudio.html) or +[RMarkdown](https://rmarkdown.rstudio.com/lesson-2.html). + +You can find installers for multiple operating systems +[here](https://posit.co/download/rstudio-desktop/). + +When starting a new R project in RStudio, always checkmark 'Use renv with this +project'. This will ensure that you create an isolated and reproducible +environment similar to those that are produced with `mamba`/`conda` or Python's +`venv`. - [RStudio UserGuide](https://docs.posit.co/ide/user/ide/get-started/) diff --git a/development-environments/conda-getting-started.md b/development-environments/conda-getting-started.md index 04de2c7..1bc8071 100644 --- a/development-environments/conda-getting-started.md +++ b/development-environments/conda-getting-started.md @@ -5,237 +5,216 @@ title: Getting Started with Conda, Virtual Environments, and Python There are many different ways to install and start using Python on your personal device, and no one way is the correct way. How one installs Python often simply comes down to personal preference. In general, we recommend using a tool called -Conda. When performing geospatial computing, you'll likely be working with -multiple projects that depend on not only Python but other languages too, like -R, Julia, or JavaScript. You may also find that you projects can't always run on -the same exact version of Python. Conda enables you to easily install and run -multiple versions of Python along with a range of other languages and software -packages. - -## Conda - -Just as there is with Python, there are multiple ways to install Conda. We -recommend using the latest -[Miniconda installer](https://docs.conda.io/en/latest/miniconda.html#latest-miniconda-installer-links). - -Conda's documentation includes installation instructions for Windows, MacOS, and -Linux -[here](https://conda.io/projects/conda/en/stable/user-guide/install/index.html#regular-installation). - -Once you have Conda installed on your machine, follow along with +`mamba`, which has been developed as a faster alternative to the popular package +manager, `conda`, and a lighter alternative to the larger Python distribution +that it's associated with, Anaconda. When performing geospatial computing, +you'll likely be working with multiple projects that depend on not only Python +but other languages too, like R, Julia, or JavaScript. You may also find that +you projects can't always run on the same exact version of Python. `conda` and +`mamba` enable you to easily install and run multiple versions of Python along +with a range of other languages and software packages. + +## `conda` and `mamba` + +Just as there is with Python, there are multiple ways to install `mamba` and +`conda`. For Windows, we recommend using the latest +[Miniforge3 installer](https://github.com/conda-forge/miniforge?tab=readme-ov-file#miniforge3) +and sticking with the recommended options. Mac OS and Linux users can copy and +run the commands listed +[here](https://github.com/conda-forge/miniforge?tab=readme-ov-file#unix-like-platforms-mac-os--linux) +within their terminal applications. + +If you've installed `mamba` on Windows and stuck with the recommended options in +the Miniforge installer, the `mamba` and `conda` commands will only be available +from the Miniforge Prompt application that was included in the installation +process. Use this application rather than Command Prompt or PowerShell. If you +want to pair `mamba` with a more functional shell environment, we've included +instructions for using `mamba` with a Bash shell on Windows in +[UNIX Shells and CLIs](https://ubc-geography.github.io/computing-resources/unix-shells-and-clis/#running-mamba-on-git-bash-for-windows). +For Mac OS and Linux users, the install script adds `mamba` to the PATH variable +thus making it available from a terminal application running a Bash shell. + +Once you have `mamba` installed on your machine, follow along with ['Getting Started With Conda'](https://conda.io/projects/conda/en/stable/user-guide/getting-started.html) -to familiarize yourself with some of Conda's basic functionalities. +to familiarize yourself with some of basic functionalities of `mamba`/`conda`. +As a reminder, Miniforge includes both tools, and they can be used +interchangeably, so use whichever one makes sense to you. ## Virtual Environments -Along with being a package manager, which makes installing and managing -software, significantly more convenient, Conda also acts as an environment -manager. Before getting started with using Conda and Python, it's important to -have an understanding of virtual environments and how Conda works with them to -install software and packages onto your machine. If you followed along with the +When you install `mamba` with Miniforge, a virtual environment is automatically +created for you, which includes an installation of Python along with `mamba` +itself. This is your base environment, and it can give you quick access to +Python in a pinch, but to ensure the stability of `mamba`, you'll want to avoid +making any changes to this environment apart from running the occasional upgrade +to `mamba`. Before getting started with using `mamba` and Python, it's important +to have an understanding of virtual environments and how `mamba` works with them +to install software and packages onto your machine. If you followed along with +the [Managing Environments](https://conda.io/projects/conda/en/stable/user-guide/getting-started.html) section of 'Getting Started With Conda', then you got a very basic introduction -to creating and using a virtual environment. +to creating and using virtual environments. -Let's walkthrough the process again by creating a virtual environment that has -JupyterLab installed. We could then install some extensions and other packages -into this environment and clone it in the future as we start new projects in -order to save ourselves a little bit of time. +Let's walkthrough the process again by creating a virtual environment that has a +newer version of Python than the one that came pre-installed in the base +environment along with the popular geospatial package, GeoPandas. To start, you will need to open a terminal on your machine. If you are using -Windows, the Conda installer would have added a new application to your machine -named Anaconda Prompt. Running this application is the recommended approach to -starting a terminal and running Conda. +Windows, use the Minforge Prompt as noted before. -Before we can start installing Conda packages, we will need to create our new -virtual environment. We will name it `jupyter`. +Before we can start installing Python and other packages, we will need to create +our new virtual environment. We will name it `py-geo`, which will remind us in +the future that this is a Python environment with geospatial packages. ```bash -$ conda create --name jupyter +$ mamba create --name py-geo ``` -Next we'll want to activate the `jupyter` virtual environment so we can start -interacting with it and installing our packages into it. +Next we'll want to activate our newly created virtual environment, so we can +start interacting with it and installing our packages into it. ```bash -$ conda activate jupyter +$ mamba activate py-geo ``` When you activate a virtual environment, the name of the environment will be prepended to your shell prompt, like so: ```bash -(jupyter) $ +(py-geo) $ ``` -Now that we have our virtual environment activated, we can install JupyterLab -along with all of its dependencies. +Now that we have our virtual environment activated, we can install the Python +version that we would like to work with alongside GeoPandas. ```bash -(jupyter) $ conda install --channel conda-forge jupyterlab +(py-geo) $ mamba install python=3.12 geopandas ``` -JupyterLab has a decent number of dependencies, one of which is Python. You will -notice that Conda lists those dependencies and asks if you want to proceed with -installing them along with Python. This is a good time to ensure you did not -enter the install command with a typo and are about to accidentally install the -wrong package. If everything looks correct, respond to the prompt to proceed. +GeoPandas has a decent number of dependencies, many of which other Python +geospatial packages also rely on. You will notice that `mamba` lists those +dependencies and asks if you want to proceed with installing them along with +Python. This is a good time to ensure you did not enter the install command with +a typo and are about to accidentally install the wrong package. If everything +looks correct, respond to the prompt to proceed. -Every package that you install with Conda includes information within it that +Every package that you install with `mamba` includes information within it that lists all of its dependent packages and the range of versions that it will be -compatible with. We can use Conda to review what dependencies were included with -JupyterLab and which version of Python has been installed within the -environment. +compatible with. We can use `mamba` to review what dependencies were included +with GeoPandas and Python itself. ```bash -(jupyter) $ conda list -# packages in environment at ...\miniconda3\envs\jupyter: +(py-geo) $ mamba list +# packages in environment at ...\miniforge3\envs\py-geo: # # Name Version Build Channel -anyio 3.7.1 pyhd8ed1ab_0 conda-forge +attrs 23.2.0 pyh71513ae_0 conda-forge ... -python 3.10.12 h4de0772_0_cpython conda-forge +python 3.12.4 h889d299_0_cpython conda-forge ... -zipp 3.16.0 pyhd8ed1ab_1 conda-forge +zstd 1.5.6 h0ea2cb4_0 conda-forge ``` You will notice that I have abbreviated the list quite a bit with ellipses, but -I can see that JupyterLab included Python 3.10.12 as a dependency for me. You -may see a newer version listed when you run this command. In a later step, we -will look at how we can upgrade or downgrade Python to another version that -remains compatible with JupyterLab. - -Okay, let us get JupyterLab up and running, with the following command: - -```bash -(jupyter) $ jupyter lab -``` - -If everything worked correctly, you will notice a new browser window has opened -with JupyterLab up and ready to go and the shell in your terminal has started -logging information from JupyterLab. Let us minimize our terminal for now to let -it continue logging info, and we will jump into a new terminal session within -JupyterLab. Because we are running JupyterLab within our virtual environment, we -will not actually see the environment name prepended to the terminal prompt as -we did before, but we can be confident that the virtual environment is activated -within our terminal. If we wanted to double-check, we could always run the -following command to list our virtual environments: - -```bash -$ conda info --envs -# conda environments: -# -base C:\Users\user\miniconda3 -jupyter * C:\Users\user\miniconda3\envs\jupyter # The * notifies us that 'jupyter' is the currently active environment -``` - -MacOS and Linux users will see different paths listed for the locations of their -virtual environments. - -From here, you can continue using Conda to install any other packages that you -want within this environment. You could add R, Julia and their accompanying -kernel packages along with some helpful JupyterLab extensions, like -`jupyterlab-git` or `jupyterlab-github`. You can also use Python's built-in -package manager to install packages that are available from the Python Package -Index (PyPI). Consider installing packages that you think would be useful in all -of your projects. - -Now that we have setup our basic JupyterLab environment, we can clone the -environment to start working on a new project, where we will install packages -that are specific to that project. First, we will shutdown our JupyterLab and -return to our original terminal. Then we will run the following commands to -deactivate our `jupyter` environment and clone it to create a new environment -named `geog` - -```bash -(jupyter) $ conda deactivate -$ conda create -n geog --clone jupyter -``` - -While cloning can be helpful for quickly copying a virtual environment on your -local machine, it is not going to be much help if you want to share a virtual -environment with someone else or transfer it to a different machine. To make the -process easy, Conda includes the ability to take a snapshot of all the packages -installed within an environment and store the name and versions of those -packages into a text-based YAML (.yml) file using the following command. +you can see that we have Python 3.12.4 installed along with GeoPandas' many +dependencies. You may see newer versions listed when you run this command. In a +later step, we will look at how we can upgrade or downgrade Python to another +version within this environment. + +To ensure your virtual environment is reproducible for both yourself and +collaborators, it's important to keep an up-to-date file that lists the packages +you used while running your code and store it alongside your code in a version +control system, like Git. `mamba` includes the ability to generate this file for +you by taking a snapshot of all the packages installed within an environment and +store the name and versions of those packages into a text-based YAML (.yml) file +using the following command. ```bash -$ conda activate jupyter -(jupyter) $ conda env export > jupyter_environment.yml +(py-geo) $ mamba env export --no-builds > environment.yml ``` -Let us make one more environment using the environment file that we just created -to see how it works, and we will just list our environments again to verify that -it was created. +To test our file, let's make one more environment using the environment file +that we just generated to see how it works, and we will just list our +environments again to verify that it was created. ```bash -(jupyter) $ conda deactivate -$ conda env create -n testenv -f jupyter_environment.yml -$ conda info --envs -# conda environments: +(py-geo) $ mamba deactivate +$ mamba env create -n testenv -f environment.yml +$ mamba info --envs +# virtual environments: # -base * C:\Users\user\miniconda3 -geog C:\Users\user\miniconda3\envs\geog -jupyter C:\Users\user\miniconda3\envs\jupyter -testenv C:\Users\user\miniconda3\envs\testenv +base * C:\Users\\miniforge3 +py-geo C:\Users\\miniforge3\envs\py-geo +testenv C:\Users\\miniforge3\envs\testenv ``` Next let us just do a little cleanup by removing the `testenv` environment that we just created and verify that it is no longer on our machine. ```bash -$ conda remove -n testenv --all -$ conda info --envs -# conda environments: +$ mamba remove -n testenv --all +$ mamba info --envs +# virtual environments: # -base * C:\Users\user\miniconda3 -geog C:\Users\user\miniconda3\envs\geog -jupyter C:\Users\user\miniconda3\envs\jupyter +base * C:\Users\\miniforge3 +py-geo C:\Users\\miniforge3\envs\py-geo ``` ## Python -Now I want to return to my `geog` environment, and rather than running Python -3.10.12, which was installed as a dependency with JupyterLab, I want to run the -latest Python release available. We can use the following commands to activate -the `geog` environment and then use Conda's search tool to see what Python -versions are available. +Now I want to return to my `py-geo` environment, and rather than running Python +3.12.4, I want to downgrade my Python version to be one minor release older. We +can use the following commands to activate the `py-geo` environment and then use +the search tool to see what Python versions are available. One important thing +to note is that `conda` and `mamba` can pull packages from different channels, +which are managed by different groups and organizations. By default, `mamba` +pulls from the `conda-forge` channel, which includes the most expansive and +up-to-date set of packages. It's often recommended that you start with the +`conda-forge` channel and stick to it. Using multiple channels in a single +environment can cause a range of conflicts that may break your environment. ```bash -$ conda activate geog -(geog) $ conda search --channel conda-forge python +$ mamba activate py-geo +(py-geo) $ mamba search python Loading channels: done -#Name Version Build Channel -python 2.7.12 0 conda-forge +#Name Version Build Channel +python 2.7.12 0 conda-forge ... -python 3.11.4 he1021f5_0 pkgs/main +python 3.12.4 h889d299_0_cpython conda-forge ``` You will notice that I have abbreviated the list quite a bit with an ellipsis, -but I currently have access to a range of Python versions from 2.7.12 to 3.11.4. +but I currently have access to a range of Python versions from 2.7.12 to 3.12.4. Now which Python version you install will heavily depend on the other packages and software that you intend to use within your environment. You will need to take a close look at what Python versions the packages that you want to use are compatible with. -At the time of writing this, the default Python version installed with -JupyterLab, 3.10.12, would actually be the best option. It is usually a good -choice to select one minor version older than the newest version of Python -(currently 3.11.4). This ensures a broader level of compatibility with a range -of packages. For many package maintainers, it can be quite a bit of work to -update their code to make it compatible with the latest minor release of Python, -so we can account for this by using an earlier minor release. +It's usually a good choice to select one minor version older than the newest +version of Python. This ensures a broader level of compatibility with a range of +packages. For many package maintainers, it can be quite a bit of work to update +their code to make it compatible with the latest minor release of Python, so we +can account for this by using an earlier minor release. + +To downgrade my version of Python from 3.12.4 to 3.11.x, I can run the following +command. + +```bash +(py-geo) $ mamba install python=3.11 +``` -Today, I am feeling a bit adventurous though, and I want to to see if I can -install a newer version of Python in my `geog` environment. I will run the -following command to update Python to the latest version compatible with -JupyterLab and all of its other dependencies. +Every October, Python releases a new minor version. In a variety of cases, it +can be useful to upgrade to the next minor release either to access a new +feature or to just keep your environment up-to-date. To update a package with +`mamba` alongside all of its dependencies and the packages that depend on it, +you can use the following command: ```bash -(geog) $ conda update --channel conda-forge python +(py-geo) $ mamba update python ``` -And voilà, I have Python 3.11.4 installed and ready to go. A newer version of -Python 3.11 may have been released since writing this, so you might actually see -a newer version installed in your environment. +And voilà, I'm back to Python 3.12.4 and ready to go. A newer version of Python +may have been released since writing this, so you might actually see a newer +version installed in your environment. And remember to test your code after each +package upgrade to ensure that it's still running as expected. diff --git a/r/README.md b/r/README.md index ad6cc91..6a2f826 100644 --- a/r/README.md +++ b/r/README.md @@ -8,6 +8,17 @@ geography research due in part to the large collection of geospatial packages that have been developed with it along with it's broad adoption for scientific computing. +The easiest and most recommended approach for getting started with R is to +download the installer from CRAN: + +- [Windows](https://cran.r-project.org/bin/windows/base/) + +- [Mac OS](https://cran.r-project.org/bin/macosx/) + +- [Linux](https://cran.r-project.org/bin/linux/) + +Additional Resources: + - _[R in Action](https://go.exlibris.link/P6rJdt9g)_ - _[R for the Rest of Us](https://learning.oreilly.com/library/view/r-for-the/9781098182199/)_ diff --git a/version-control-systems/README.md b/version-control-systems/README.md index 8a054b9..308789a 100644 --- a/version-control-systems/README.md +++ b/version-control-systems/README.md @@ -20,10 +20,23 @@ Git is by far the most popular version control system and comes with a powerful command line interface while integrating with code sharing and development platforms, like GitHub and GitLab. +UBC Library Research Commons frequently runs introductory workshops on Git and +GitHub, which are listed +[here](https://libcal.library.ubc.ca/calendar/?t=g&q=git). And the materials for +these workshops are available below: + - [UBC Library Research Commons - Introduction to Git and GitHub](https://ubc-library-rc.github.io/intro-git/) +Additionally, the SFU's Research Computing Group provides a full-day workshop on +Bash during their annual Summer School in early June with some of the materials +for that course available below: + - [Digital Research Alliance - Git Tutorial and Workshops](https://mint.westdri.ca/git/) +Additional Resources: + +- [Software Carpentry - Version Control with Git](https://swcarpentry.github.io/git-novice/) + - _[Pro Git](https://git-scm.com/book/en/v2)_ - _[Beginning Git and GitHub: Version Control, Project Management and Teamwork for the New Developer](https://go.exlibris.link/G3VfpGll)_