notebooks/git_primer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cd86eca9-4ca5-4aea-ab09-bb6416a72d35",
   "metadata": {},
   "source": [
    "# Git Primer\n",
    "\n",
    "*J. Runnoe* <br>\n",
    "*August, 2023*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "062f0a43-4514-4b54-ae3a-4e4f619f34ec",
   "metadata": {},
   "source": [
    "---\n",
    "## Contents\n",
    "* [Version Control](#intro)\n",
    "* [Install Git](#git)\n",
    "* [Practice Git](#gitpractice)\n",
    "* [GitHub Workflow](#github)\n",
    "* [ASTR8060 and Git](#classgit)\n",
    "    * [Setting Up Your Working Directory](#estup)\n",
    "    * [Best Practices for Git](#best)\n",
    "    * [Class Rules for Git](#rules)\n",
    "* [Common Commands](#commands)\n",
    "* [Summary](#summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e0b110b-0550-4aa9-a37c-c82392f41fce",
   "metadata": {},
   "source": [
    "---\n",
    "## Version Control <a class=\"anchor\" id=\"intro\"></a>\n",
    "\n",
    "In software development, version control is a class of tools designed to help a team manage changes to code over time.  The development of codes using a common user repository is a feature of modern work in large collaborations -- it is partly how large surveys such as the Sloan Digital Sky Survey (SDSS) have been able to be so successful.  \n",
    "\n",
    "Git, Mercurial, and SubVersion (SVN) are a few examples of common version control software.  They share the practice of keeping track of how codes change as the development team fixes bugs and implements new features.  Beyond that, there are some general differences in workflow (a consistent recipe for using version control software to accomplish tasks).  SVN maintains a central repository called the trunk from which users check out a working copy.  They can then pull changes from other users to update their local copy and commit any subsequent changes that they make.  With SVN, the user does not necessarily have the entire repository stored locally.  Mercurial and Git are *distributed* version control systems, meaning that each user actually clones the entire repository locally.  All copies of the repository are created equally, so users can push and pull their changes among the distributed system as necessary.  Another way that Mercurial and Git are different from SVN is that they actually track the *changes*, rather than the files themselves, which saves space.  Mercurial and Git have many similarities, but we will be using Git in this course because it is by far the most commonly used version control system in the world."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fb7079b-c59b-442a-9987-fdcad731da88",
   "metadata": {},
   "source": [
    "---\n",
    "## Install Git <a class=\"anchor\" id=\"git\"></a>\n",
    "\n",
    "Git is an example of version control software. If you have a Mac, it is probably already installed on your computer. If not, or if you are on another platform, you can get it for any operating system from their download page: [https://git-scm.com/downloads](https://git-scm.com/downloads/)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f2ba5fb-4d4b-4da5-9e63-58ea48ce8235",
   "metadata": {},
   "source": [
    "1. Check whether Git is installed on your computer:<br>\n",
    "   `$ which git` <br>\n",
    "   <font color='gray'>/usr/bin/git</font>\n",
    "\n",
    "    `$ git --version`<br>\n",
    "    <font color='gray'>git version 2.37.1 (Apple Git-137.1) </font><br>\n",
    "\n",
    "2. If Git is not installed, download the appropriate installer and follow the prompts to install it.\n",
    "\n",
    "3. If this is your first time using Git, configure it so that it has your name and email: <br>\n",
    "`$ git config --global --edit`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e505ee6-c5dc-4085-9426-9e7c3c197a55",
   "metadata": {},
   "source": [
    "---\n",
    "## Practice Git <a class=\"anchor\" id=\"gitpractice\"></a>\n",
    "\n",
    "Let’s make a dummy repository to learn the ins and outs of using Git on your local machine. To get started, you’ll need an open terminal window and your favorite text editor. In the terminal, create a directory and change into it. Then issue these commands to initialize your own test repository:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d73202e8-2e59-4eba-8a0e-173ed5e1bbdb",
   "metadata": {},
   "source": [
    "Use a terminal window to make a dummy directory and initializes it as a Git repository: <br>\n",
    "`$ mkdir test_repo` <br>\n",
    "`$ cd test_repo` <br>\n",
    "`$ git init` <br>\n",
    "\n",
    "Now let's make and commit your first file. I’ll pretend I’m making a grocery list, which I will add to the staging area and commit: <br>\n",
    "`$ echo “Avocado” >> shopping.txt` <br>\n",
    "`$ git add shopping.txt` <br>\n",
    "`$ git commit -m \"Added list of groceries.\"` <br>\n",
    "\n",
    "Now you can open groceries.txt in your text editor, update the text a few times, and make several commits. Remember to use git add each time to track changes to the staging area and use an informative message with each commit. However, be wary of using `git add *` because it may pick up temporary files.\n",
    "\n",
    "After I have updated my test file many times, my log of commits looks like this (the top is the most recent):<br>\n",
    "`$ git log –oneline`<br>\n",
    "<font color='gray'>8fd949c Updated car parts.<br>\n",
    "38d46d7 Added car parts.<br>\n",
    "8ab1d45 Updated breakfast foods. 41bda62 Added breakfast foods.<br>\n",
    "efdc3d5 Added avocado toast ingredients. 2c689a3 Added list of groceries<br></font>\n",
    "\n",
    "At the end, I started adding car parts to my list of groceries. That's a little crazy, so I want to revert back to an earlier version of the groceries file. There are several ways to do this in Git, but we will use git revert because it maintains a logical file history and is therefore best for collaborative projects. If I use `git revert head`, Git will make a new commit that is the inverse of the last one. This only lets you go one commit back, because executing it a second time reverts the revert. Since I have two commits worth of groceries that I want to revert, I can specify the hash (or ID) of the commit I want to go back to:<br>\n",
    "`$ git revert --no-commit 8ab1d45..head` <br>\n",
    "`$ git commit -m \"Reverted to commit before car parts were added to grocery list.\"` <br>\n",
    "\n",
    "The `–no-commit` option just lets you use your own more informative commit message instead of the default one generated by git revert. Now the crazy car parts changes are still stored in my history (and I could go back and view or adopt them if I want to), but my current working file does not include those changes and the revert is preserved in the history: <br>\n",
    "\n",
    "`$ git log –oneline`<br>\n",
    "<font color='gray'>461dff4 Reverted to commit before car parts were added to grocery list.  <br>\n",
    "8fd949c Updated car parts. <br>\n",
    "38d46d7 Added car parts. <br>\n",
    "8ab1d45 Updated breakfast foods. <br>\n",
    "41bda62 Added breakfast foods. <br>\n",
    "efdc3d5 Added avocado toast ingredients. 2c689a3 Added list of groceries. <br></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5a4480a-563a-4893-9ece-9bd15cd74f95",
   "metadata": {},
   "source": [
    "If you just want to go back and look at the state of your directory several commits ago, you can use `git checkout`.  Please be careful to use this only to explore your directory and look at code in the previous state.  Commits and branches in this case can result in a detached head, which will complicate a shared history among your classmates.\n",
    "\n",
    "What about moving, renaming, and deleting files when they're version controlled with Git?  Deleting a document is simple, use `git rm` to delete and stage it, and then make a commit noting that you removed that file (alternatively, you can use the UNIX `rm` command and then either `git rm` or `git add` to stage it before the commit).  If you want to rename a file, use `git mv` rather than the UNIX command so that Git knows the file has been renamed.  If you accidentally use the UNIX `mv` command, you can rename the file back and Git will never know.  Play around with some of the tutorials in the links section until you feel comfortable with basic operations in Git. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43cf9b4a-de02-4801-8e89-dfb6f1ec2362",
   "metadata": {},
   "source": [
    "---\n",
    "## GitHub Workflow <a class=\"anchor\" id=\"github\"></a>\n",
    "\n",
    "GitHub is a host for git repositories. If you do not already have a (free) [GitHub](https://github.com/) account, make one now.\n",
    "\n",
    "Git has multiple common workflows, we will use \"forking workflow\" that is commonly associated with Github.  The recipe to track a change in Git with this workflow is to select files that you want to track to a *staging area*.  Then, you write a message summarizing the work you have done and commit the changes. When you are ready, you can push your changes to your server-side repository, and create a pull request for the \"official\" server-side repository which will constitute your submission."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d18cf33a-de86-481a-8099-3ae55e923d23",
   "metadata": {},
   "source": [
    "1. Fork the class repository on Github (you will need your GitHub account).\n",
    "\n",
    "   ![github_fork](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_001.jpeg)\n",
    "\n",
    "   The new fork on my personal account looks like this:\n",
    "\n",
    "   ![github_forked](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_002.jpeg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fe47dbb-1d69-4b11-9807-72c1cc2e7392",
   "metadata": {},
   "source": [
    "2. Clone the new repository to your local machine. Use the URL for your fork on your Github account. <br>\n",
    "   `$ git clone https://github.com/YOUR_USERNAME/astr8060_f23 .`\n",
    "\n",
    "   It looks like this for me:\n",
    "   ![github_forked](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_003.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b942d36-5f23-490e-a74b-c93725615878",
   "metadata": {},
   "source": [
    "3. Configure your remotes. Use “origin” for your Github repo (this was done automatically when you cloned):<br>\n",
    "   `$ git remote -v` <br>\n",
    "    <font color=gray>origin\thttps://github.com/runnoejc/astr_8060_f23/ (fetch)<br>\n",
    "    origin\thttps://github.com/runnoejc/astr_8060_f23/ (push)<br></font>\n",
    "\n",
    "   Set your main Github class repo as \"upstream\". We will all use the same URL for this one so that we all grab changes from the same place.<br>\n",
    "   `$ git remote add upstream https://github.com/VanderbiltAstronomy/astr8060_f23.git`<br>\n",
    "\n",
    "   Check that this worked:</br>\n",
    "   `$ git remote -v` <br>\n",
    "    <font color=gray>origin\thttps://github.com/runnoejc/astr_8060_f23/ (fetch)<br>\n",
    "    origin\thttps://github.com/runnoejc/astr_8060_f23/ (push)<br>\n",
    "    upstream\thttps://github.com/VanderbiltAstronomy/astr_8060_f23.git (fetch)<br>\n",
    "    upstream\thttps://github.com/VanderbiltAstronomy/astr_8060_f23.git (push)<br></font>\n",
    "\n",
    "   It looks like this for me:\n",
    "   ![github_forked](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_004.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e3a56fd-6c3c-4cc2-b321-c8d0763bc725",
   "metadata": {},
   "source": [
    "4. Now we will set up your workspace. Create your working directory in work/your_username/:<br>\n",
    "   `$ cd ./work.`<br>\n",
    "   `$ mkdir your_username`<br>\n",
    "   `$ touch .gitkeep` <br>\n",
    "\n",
    "   Track the changes locally with:<br>\n",
    "   `$ git add .gitkeep` <br>\n",
    "   `$ git commit -m \"Added your_username directory with a gitkeep.\"`<br>\n",
    "\n",
    "   Prepare to send these changes to GitHub. First, check the *class repository* to see whether there are any changes made by classmates that you need to download:<br>\n",
    "   `$ git pull upsteam main`<br>\n",
    "   <font color=gray>From https://github.com/VanderbiltAstronomy/astr_8060_f23 <br>\n",
    "      \\* branch            main       -> FETCH_HEAD<br>\n",
    "      \\* [new branch]      main       -> upstream/main<br>\n",
    "   Already up to date.<br></font>\n",
    "\n",
    "   Now send your changes *to your repository fork* on GitHub:<br>\n",
    "   `$ git push origin main` <br>\n",
    "\n",
    "   It looks like this for me:\n",
    "   ![github_forked](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_005.jpeg) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a47903c-2c8a-45d6-a4d2-98d01b99d528",
   "metadata": {},
   "source": [
    "5. To \"submit\" work, you will need to create a pull request. Go to [https://github.com/VanderbiltAstronomy/astr8060_f23](https://github.com/VanderbiltAstronomy/astr8060_f23) and select \"Pull requests\".<a class=\"anchor\" id=\"submit\"></a>\n",
    "\n",
    "   ![github_forked](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_006.jpeg)\n",
    "\n",
    "   You will need to compare the state of the repositories across forks to get it to find your changes:\n",
    "\n",
    "   ![github_forked](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_007.jpeg)\n",
    "\n",
    "   Select your fork from the dropdown menu:\n",
    "   \n",
    "   ![github_forked](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_008.jpeg)\n",
    "\n",
    "   Before you submit, write me a helpful note.\n",
    "\n",
    "   ![github_forked](http://astro.phy.vanderbilt.edu/~runnojc1/media/jupyter/git_workflow_imgs/git_workflow_imgs_009.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a49a2b69-0ce5-4673-b018-61e1984bc434",
   "metadata": {},
   "source": [
    "Overall, your workflow should look like this:\n",
    "* Change code in your local repo.\n",
    "* Commit to your local repo with `git add` and `git commit`.\n",
    "* Pull changes from the VanderbiltAstronomy repo with ` ",
    "git pull upstream main`.\n",
    "* Do the above as much as you want while you work.\n",
    "* Push changes to your personal Github fork with ` ",
    "git push origin main`.\n",
    "* Do the above as much as you want while you work.\n",
    "* To submit an assignment: go to [https://github.com/VanderbiltAstronomy/astr_8060_s23](https://github.com/VanderbiltAstronomy/astr_8060_s23) and manually submit a pull request."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de83a4d2-81ec-4d31-8508-59227bf4dfb7",
   "metadata": {},
   "source": [
    "---\n",
    "## ASTR8060 and Git <a class=\"anchor\" id=\"classgit\"></a>\n",
    "\n",
    "In this class, we will use a Git repository to distribute course material and submit (but not grade) work. For instance, homeworks will be submitted by uploading code and/or documents to our Git repository by the stated deadline. \n",
    "\n",
    "Think of a Git repository as a collaborative directory to which multiple people have access.  The directory is special in that it uses snapshots to track how it changes with time, and logs information on who has made the changes.  That way, it's possible for any user who has a clone of the repository to track changes and use anything in the repository.  Git is not intended for tracking large data files, so think code and documents.\n",
    "\n",
    "Every document or piece of code in the class Git repository will be available for everyone in the class to use and edit.  If you are worried about other students copying your homework (and other) submissions, note that a simple `diff` in UNIX, and/or logging via `git diff`, will make it obvious to me if another student has directly copied your submission.  In fact, frequently uploading your work to the Git repository as you write and develop it will make it far harder for your work to be copied than uploading it in a single submission.  It is always possible to return a Git repository to an earlier state, so any unwanted changes can be easily redacted."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e02264c-9269-44a9-8fe7-cf25d8e7e360",
   "metadata": {},
   "source": [
    "### Setting up your working directory <a class=\"anchor\" id=\"setup\"></a>\n",
    "\n",
    "Our directory -- our Git repository -- sits on the Vanderbilt Astronomy Github page. The difference between this repository and the one you just practiced on is that this one will be cloned onto all of your classmates computers in a way that can interact with your own. By the time you get here, you should have learned how to fork the class repository on Github and then clone it to your local machine.\n",
    "\n",
    "Our class repository is structured as follows. Beneath the parent directory, which is called I have put a directory `work/runnoe/`.\n",
    "\n",
    "This directory is my personal workspace. You should similarly create a directory that is your name and beneath it you will create directories for homework assignments and data reduction tasks: <br>\n",
    "\n",
    "`ASTR8060/work/YOUR_USERNAME` <br>\n",
    "`ASTR8060/work/YOUR_USERNAME/homework` <br>\n",
    "\n",
    "Now create a working directory with your name, plus a directory for your homework submissions. <br>\n",
    "`cd ASTR8060/work/` <br>\n",
    "`mkdir runnoe` <br>\n",
    "`cd runnoe/` <br>\n",
    "`mkdir homework` <br>\n",
    "`cd homework/` <br>\n",
    "`touch .gitkeep` <br>\n",
    "`git add .gitkeep` <br>\n",
    "`git commit -m \"Added empty homework working dir with dummy keep file.\"` <br>\n",
    "\n",
    "Note that Git won't let you add an empty directory to your repository, so adding an empty .gitkeep file is the industry standard workaround. This commit has only been made to your local version of the repository but has not yet been communicated to your classmates via our remote repository. In general, it is considered good practice to make sure your repository is completely up to date relative to the remote repo before you push any of your own changes and issue a pull request. So first, evaluate whether you are out of date:<br>\n",
    "\n",
    "`git fetch`<br>\n",
    "`git status`<br>\n",
    "\n",
    "If your local repository is out of date due to changes made by your classmates, git status will tell you. The next step is to pull the latest state of the remote repository to your local clone and merge any changes: <br>\n",
    "\n",
    "`git pull upstream main`<br>\n",
    "\n",
    "The workflow that described for the class will make merging changes very simple since you will never be editing the same files as your classmates. Thus, merging should largely be handled by Git and will be pretty straightforward by following the prompts. Now you are ready to push your changes to *your GitHub fork*:<br>\n",
    "`git push origin master`<br>\n",
    "\n",
    "This will send your updated `homework/` directory to your server-side Github repository. You can execute this workflow as much and as often as you like. When you are ready to submit work, go to your Github account and submit a pull request following [these instructions](#submit). Experiment with this local workflow until you are comfortable using it and understand the outputs from git log and git status. Ask if you have questions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5bad414-83cb-404f-b979-2326761eb634",
   "metadata": {},
   "source": [
    "### Best Practices for Git <a class=\"anchor\" id=\"best\"></a>\n",
    "\n",
    "There are various examples of good Git etiquette for our workflow to help people share documents and code:\n",
    "\n",
    "1. Always `git fetch` and then `git pull` before committing anything new to the directory.  This way, if somebody else commits something new just before you, then you won't lose track of which version of the directory you're working with.\n",
    "2. Git is for storing code and documents, *not large data files*.  Large data files will make the repository slow to operate.  If you have a large data file, keep it local to your machine and share it with people in other ways. In particular, do not put the Imaging/ data set for the reduction assignments in our repository.\n",
    "3. Git requires good coding practices.  Place comments within the body of your code carefully using your initials.  So, my code will have many comment lines of the form, e.g., `# JCR this line of code does this`.  When writing documents collaboratively, make similar comments if you make major changes to the document.\n",
    "4. When you commit a new document using the `git commit` command, *always* provide a comment as in `git commit -m \"this is what I did\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92baacf3-2a66-4777-948c-c64afc47262a",
   "metadata": {},
   "source": [
    "### Class Rules for Git <a class=\"anchor\" id=\"rules\"></a>\n",
    "\n",
    "1. Do not edit code written by another member of the class without their permission.  The reason for this is twofold: a) it maintains separate spaces for each student to submit their independent work and b) it facilitates a workflow that makes merging changes to the repository straightforward.  *Editing other people's code that is placed in any directory that contains their name (i.e. `ASTR8060/theirname/HWx/somecode`) will be considered grounds for failing the course.*\n",
    "2. It is permissible to read and to make a copy of any member of the class's code *after* it has been graded as a homework submission...so, on HW2, it will be permissible to raid people's *HW1* directory.  But, use other people's code by making a copy of it in your personal directory or linking to it in full.  *Do not edit it in their directory.  Editing other people's code that is placed in any directory that contains their name (i.e. `theirname/HWx/somecode`) will be considered grounds for failing the course.* If you have questions about whether it is okay to look at your classmate's code in specific situations, just ask!\n",
    "3. Provide your own homework solutions.  Do not copy each other's work.  It is very easy for me to check in Git whether your homework submission greatly resembles another student's submission.  *Plagiarizing each other's homework submissions will be considered grounds for failing the course.* Feel free to discuss homework problems and issues with each other but *write your own submissions sitting by yourself.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "254a43ac-3a6d-483c-aabd-9a3a5106990b",
   "metadata": {},
   "source": [
    "---\n",
    "## Common Commands <a class=\"anchor\" id=\"commands\"></a>\n",
    "\n",
    "`git status` <br>\n",
    "This command prints the status of your repository to the screen.  It will tell you about files that are added, tracked, missing, or renamed as well as the state of your local repository clone relative to the remote. <br>\n",
    "\n",
    "`git fetch` <br>\n",
    "This command queries the remote class repository to see whether there are any changes since your last pull.  Issue it *before pushing any changes to the remote repository*. <br>\n",
    "\n",
    "`git pull` <br>\n",
    "This command downloads and merges changes to your local directory to mirror the current copy of the remote repository.  Issue this command in combination with `git fetch` *often*.<br>\n",
    "\n",
    "`git push` <br>\n",
    "This command sends your commit history and changes to the remote repository.  Always issue `git fetch` and `git pull` to merge any changes *before* pushing your own updates to the remote. <br>\n",
    "\n",
    "`git add a_new_file` <br>\n",
    "This adds a file to the staging area to be included in the next commit.  Issue it every time you want to commit a file.  Use `git status` to find modified files that are not staged for a commit. <br>\n",
    "\n",
    "`git commit -m \"this is what I did\"` <br>\n",
    "This command commits a file you are working on to the local repository.  It will be committed to the directory in the repository that mirrors the directory that you are in locally.  The `-m` switch commits a comment that will be logged by Git. *Always include a comment*.<br>\n",
    "\n",
    "`git log` <br>\n",
    "This command lists all of the changes to the repository.  Use `git log --oneline` for a compact, easy-to-read version.  To see recent changes, pipe it to `more` at the command line (e.g., `git log | more`).  To see changes somebody specific made, `grep` that person's username at the command line (e.g., `git log | grep runnoe -A 3`). <br>\n",
    "\n",
    "`git ls-files` <br>\n",
    "This command lists what is in the repository. This is a useful command as you may expect to find a file in the Git repository when, in fact, you forgot to add or commit that file. This command, then, will allow you to see what is actually in the repository as compared to what is in your local directory. <br>\n",
    "\n",
    "`git diff revA..revB` <br>\n",
    "This command shows the differences in the repository between commits with hashes A and B.  This allows you to track changes that people have made.  One use, e.g., would be to see who has added what to a LaTeX document since you went to bed last night. <br>\n",
    "\n",
    "If you find yourself using many other different commands, feel free to add them to this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cb08115-299d-4d2f-8c00-e1c9362d3b4a",
   "metadata": {},
   "source": [
    "---\n",
    "## Summary <a class=\"anchor\" id=\"summary\"></a>\n",
    "\n",
    "At this point, all of you should have:\n",
    "* Have Git set up on your computer.\n",
    "* An understanding of what version control is.\n",
    "* Have beginning literacy with command-line git.\n",
    "* Have Github account and workflow for class homework submission.\n",
    "* Know the class rules for Git."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31fd057a-6138-4c6f-b356-db2a6929db72",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "837dd358-6b59-4668-b6ad-2904e34288ae",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d2a9b5c-cbde-451c-8e1d-238dbb108b4c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3",
   "language": "python",
   "name": "py3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}