Adding More Project Structure

Adding a datasets folder

We’ll now add a datasets folder containing the data we’ll work with.

First, let’s create an empty datasets folder and then check the status:

> git status
On branch main
nothing to commit, working tree clean

The reason we don’t see the newly created folder in our status is because Git does not track empty folders. A directory can only become part of the repository once it contains at least one file (even if this file were just a placeholder).

Let’s add our first dataset, a CSV (Comma-Separated Values) file that stores data in tabular format. CSV is a good choice for storing simple, not very large tabular data, because it is an open, text-based format that is easy to inspect with any text editor and easy to track by Git.

The dataset will contain:

• a small header row (metadata that describes the data in each column),
• several rows of data, where each value is separated by a delimiter (usually a comma, but other characters like semicolons or tabs can be used as delimiters too).

Feel free to use your own data or copy the sample below into a file called water-usage.csv in your datasets folder.

Sample: water-usage.csv

start-value,end-value,category
247.909,247.988,wool
248.598,248.719,towels
249.232,249.337,bedding

As soon as we have added the CSV file to the datasets folder, Git will notice there is new content in the repository.

> git status
On branch main

Untracked files:
  (use "git add <file>..." to include in what will be committed)
          datasets/

nothing added to commit but untracked files present (use "git add" to track)

We can use git add <folder>/ to stage a folder and all its contents, including possible subfolders (recursively). Folders with only one file like our datasets folder are nothing special, Git behaves the same way whether a folder contains one file or a hundred.

> git add datasets/
On branch main

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
          new file:   datasets/water-usage.csv

Skipping the staging area

If we now populate our dataset with further collected values and check our status again, these changes are still to be staged:

> git status
On branch main

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
          new file:   datasets/water-usage.csv

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
          modified:   datasets/water-usage.csv

To commit the dataset along with the recent edits, we can stage these changes, e.g., using git add datasets/water-usage.csv and then commit like before. Alternatively, we can skip the staging area by adding the -a flag to the git commit command, which will make Git automatically stage every change for every tracked file before doing the commit. We can also combine the two flags -a and -m together for brevity:

> git commit -am "Add datasets/ with water usage data in CSV format"
[main f65231f] Add datasets/ with water usage data in CSV format
1 file changed, 53 insertions(+)
create mode 100644 datasets/water-usage.csv

Skipping the staging area is very convenient, but you need to be careful with it, as you may accidentally include unwanted or unrelated changes in a commit. It also only stages files that Git is already tracking, so it would not have worked on our CSV file if we had not git-added it first.

It is possible, though, to stage all new and modified files at once by using the git add -A command. But the same caveat applies: Use it only when all the changes belong together in the same commit.

Undoing changes

If you have staged more changes than you wanted to or even committed them, it is still possible to undo things. And Git provides you with hints on how you can go about some of these undos when you run git status.

For instance, to unstage an accidental change, use git restore --staged <file>. This command will leave your working directory unchanged, unless you forget the --staged flag – recall from the previous lesson that git restore <file> does discard any unstaged changes in the working directory. These are not the only options and arguments for git restore – which ones you end up using depends on which types of changes you want to throw away.

To redo a commit with small corrections – to reword the commit message, or add related files or changes you forgot before committing – you should:

• Stage anything you’ve missed.
• Commit again using the --amend flag.

To undo a commit, you can use git reset. This command moves your branch to a different commit and, depending on the options you use, it may delete your changes.