more detail

brownsarahm · brownsarahm · commit e09e3bc1176b · 2025-10-14T12:02:06.000-04:00
diff --git a/notes/2025-10-09.md b/notes/2025-10-09.md
@@ -588,16 +588,21 @@ We need to write the hash of the second commit to the main file to put that comm
 
 +++{"lesson_part": "main"}
 
-## stash
+## Stashing 
+
+[git stash](https://git-scm.com/book/en/v2/Git-Tools-Stashing-and-Cleaning)
+
++++{"lesson_part": "main"}
+
+Imagine you have worked on something part way, but not finished it, so you do not want to make a commit yet, but you need to switch and work on something else.  
++++{"lesson_part": "main"}
+
+let's create such a scenario in our github inclass repo
 ```{code-cell} bash
 :tags: ["skip-execution"]
 cd ../gh-inclass-fa25-brownsarahm/
 ```
 
-+++{"lesson_part": "main","type":"output"}
-
-```{code-block} console
-```
 
 +++{"lesson_part": "main"}
 
@@ -615,26 +620,9 @@ Your branch is up to date with 'origin/organization'.
 nothing to commit, working tree clean
 ```
 
-+++{"lesson_part": "main"}
-
-```{code-cell} bash
-:tags: ["skip-execution"]
-ls
-```
-
-+++{"lesson_part": "main","type":"output"}
-
-```{code-block} console
-abstract_base_class.py	important_classes.py
-alternative_classes.py	LICENSE.md
-API.md			README.md
-CONTRIBUTING.md		scratch.ipynb
-docs			setup.py
-example.md		tests
-helper_functions.py
-```
 
 +++{"lesson_part": "main"}
+We will add some new work to the README
 
 ```{code-cell} bash
 :tags: ["skip-execution"]
@@ -668,6 +656,7 @@ no changes added to commit (use "git add" and/or "git commit -a")
 ```
 
 +++{"lesson_part": "main"}
+If we want to switch branches now, 
 
 ```{code-cell} bash
 :tags: ["skip-execution"]
@@ -682,9 +671,26 @@ error: Your local changes to the following files would be overwritten by checkou
 Please commit your changes or stash them before you switch branches.
 Aborting
 ```
+we get an error
 
+
+:::::{important}
+this is git protecting you
+
+`git checkout main` would:
+- read the `.git/refs/heads/main` file 
+- read the commit at that hash
+- use the tree for that commit and write files reading from the blob objects and to the file names in the tree
+- upate the HEAD pointer
+
+this would include writing the `README` with the content as of our last commit on the main branch, and over writing the current version, so we would lose anything that has not been commited. 
+:::::::
 +++{"lesson_part": "main"}
 
+`git stash`
+stores temporary changes without making a commit so that we can come back to them. 
+
+
 ```{code-cell} bash
 :tags: ["skip-execution"]
 git stash
@@ -697,6 +703,7 @@ Saved working directory and index state WIP on organization: e899a0e begin reorg
 ```
 
 +++{"lesson_part": "main"}
+we can see what we have stashed: 
 
 ```{code-cell} bash
 :tags: ["skip-execution"]
@@ -710,6 +717,7 @@ stash@{0}: WIP on organization: e899a0e begin reorg
 ```
 
 +++{"lesson_part": "main"}
+now we can switch
 
 ```{code-cell} bash
 :tags: ["skip-execution"]
@@ -723,24 +731,9 @@ Switched to branch 'main'
 Your branch is up to date with 'origin/main'.
 ```
 
-+++{"lesson_part": "main"}
-
-```{code-cell} bash
-:tags: ["skip-execution"]
-git sttatus
-```
-
-+++{"lesson_part": "main","type":"output"}
-
-```{code-block} console
-git: 'sttatus' is not a git command. See 'git --help'.
-
-The most similar command is
-	status
-```
 
 +++{"lesson_part": "main"}
-
+and apply the changes
 ```{code-cell} bash
 :tags: ["skip-execution"]
 git stash apply
@@ -765,9 +758,11 @@ Untracked files:
 
 no changes added to commit (use "git add" and/or "git commit -a")
 ```
+we got a merge conflict, but that is okay
 
 +++{"lesson_part": "main"}
 
+we can fix it
 ```{code-cell} bash
 :tags: ["skip-execution"]
 nano README.md 
@@ -779,65 +774,14 @@ nano README.md
 ```
 
 +++{"lesson_part": "main"}
-
-```{code-cell} bash
-:tags: ["skip-execution"]
-git status
-```
-
-+++{"lesson_part": "main","type":"output"}
-
-```{code-block} console
-On branch main
-Your branch is up to date with 'origin/main'.
-
-Unmerged paths:
-  (use "git restore --staged <file>..." to unstage)
-  (use "git add <file>..." to mark resolution)
-	both modified:   README.md
-
-Untracked files:
-  (use "git add <file>..." to include in what will be committed)
-	.secret
-
-no changes added to commit (use "git add" and/or "git commit -a")
-```
-
+then  add and commit
 +++{"lesson_part": "main"}
 
 ```{code-cell} bash
 :tags: ["skip-execution"]
 git add README.md 
 ```
 
-+++{"lesson_part": "main","type":"output"}
-
-```{code-block} console
-```
-
-+++{"lesson_part": "main"}
-
-```{code-cell} bash
-:tags: ["skip-execution"]
-git status
-```
-
-+++{"lesson_part": "main","type":"output"}
-
-```{code-block} console
-On branch main
-Your branch is up to date with 'origin/main'.
-
-Changes to be committed:
-  (use "git restore --staged <file>..." to unstage)
-	modified:   README.md
-
-Untracked files:
-  (use "git add <file>..." to include in what will be committed)
-	.secret
-
-```
-
 +++{"lesson_part": "main"}
 
 ```{code-cell} bash
@@ -873,55 +817,17 @@ Untracked files:
 nothing added to commit but untracked files present (use "git add" to track)
 ```
 
-+++{"lesson_part": "main"}
 
-```{code-cell} bash
-:tags: ["skip-execution"]
-git blame
-```
++++{"lesson_part": "main","type":"heading"}
 
-+++{"lesson_part": "main","type":"output"}
+## Git can help with Debugging
+
+[chapter](https://git-scm.com/book/en/v2/Git-Tools-Debugging-with-Git)
 
-```{code-block} console
-usage: git blame [<options>] [<rev-opts>] [<rev>] [--] <file>
-
-    <rev-opts> are documented in git-rev-list(1)
-
-    --[no-]incremental    show blame entries as we find them, incrementally
-    -b                    do not show object names of boundary commits (Default: off)
-    --[no-]root           do not treat root commits as boundaries (Default: off)
-    --[no-]show-stats     show work cost statistics
-    --[no-]progress       force progress reporting
-    --[no-]score-debug    show output score for blame entries
-    -f, --[no-]show-name  show original filename (Default: auto)
-    -n, --[no-]show-number
-                          show original linenumber (Default: off)
-    -p, --[no-]porcelain  show in a format designed for machine consumption
-    --[no-]line-porcelain show porcelain format with per-line commit information
-    -c                    use the same output mode as git-annotate (Default: off)
-    -t                    show raw timestamp (Default: off)
-    -l                    show long commit SHA1 (Default: off)
-    -s                    suppress author name and timestamp (Default: off)
-    -e, --[no-]show-email show author email instead of name (Default: off)
-    -w                    ignore whitespace differences
-    --[no-]ignore-rev <rev>
-                          ignore <rev> when blaming
-    --[no-]ignore-revs-file <file>
-                          ignore revisions from <file>
-    --[no-]color-lines    color redundant metadata from previous line differently
-    --[no-]color-by-age   color lines by age
-    --[no-]minimal        spend extra cycles to find better match
-    -S <file>             use revisions from <file> instead of calling git-rev-list
-    --[no-]contents <file>
-                          use <file>'s contents as the final image
-    -C[<score>]           find line copies within and across files
-    -M[<score>]           find line movements within and across files
-    -L <range>            process only line range <start>,<end> or function :<funcname>
-    --[no-]abbrev[=<n>]   use <n> digits to display object names
 
-```
 
 +++{"lesson_part": "main"}
+blame tells us who and when each line of  a file was last changed. 
 
 ```{code-cell} bash
 :tags: ["skip-execution"]
@@ -946,6 +852,38 @@ ff9fb6ce (Sarah M Brown 2025-10-09 13:24:28 -0400 12) > | LICENSE.md | the info
 ff9fb6ce (Sarah M Brown 2025-10-09 13:24:28 -0400 13) > | CONTRIBUTING.md | instructions for how people can contribute to the project|
 ```
 
+we can also view this with annotation and visually in GitHub
+
+
+git will help you do a binary search to find what commit introduced a bug. 
+
++++{"lesson_part": "main"}
+we have to tell it to start, then tell it that the current commit is bad, then tell it the last good commit (or a reference to it)
+
+```
+git bisect start
+git bisect bad
+git biset good <ref>
+```
+
+
+
+
+To do this we need to have to tell it what commit was good, this is one of the reasons that using tags can be helpful 
+
+
++++{"lesson_part": "main"}
+
+ there are multiple ways to refer to a point in the history
+
+[revision selection](https://git-scm.com/book/en/v2/Git-Tools-Revision-Selection)
+
+
+
++++{"lesson_part": "main"}
+First let's choose a point to use as our last good commit by scanning the previous commits. 
+
+
 +++{"lesson_part": "main"}
 
 ```{code-cell} bash
@@ -985,7 +923,7 @@ Date:   Thu Sep 11 14:49:01 2025 +0000
 ```
 
 +++{"lesson_part": "main"}
-
+We will start `git bisect` first, this is our search for the "bad commit" 
 ```{code-cell} bash
 :tags: ["skip-execution"]
 git bisect start 
@@ -999,6 +937,7 @@ status: waiting for both good and bad commits
 
 +++{"lesson_part": "main"}
 
+Now, lets tell it that the current commit is bad, this reprsents that we just rcevied the bug report. 
 ```{code-cell} bash
 :tags: ["skip-execution"]
 git bisect bad
@@ -1010,7 +949,12 @@ git bisect bad
 status: waiting for good commit(s), bad commit known
 ```
 
+
+now we get the updated status
+
 +++{"lesson_part": "main"}
+next we tell it what was the last known, not necessarily the last, good commit.  We'll use the about branch commit. This would represent a case where maybe we switched to to that branch locally, ran a test for the the new bug and it passed. 
+
 
 ```{code-cell} bash
 :tags: ["skip-execution"]
@@ -1026,6 +970,8 @@ Bisecting: 0 revisions left to test after this (roughly 1 step)
 
 +++{"lesson_part": "main"}
 
+Then we check each commit it checkout for us and label it as good or bad by seeing if the budg exists there. 
+
 ```{code-cell} bash
 :tags: ["skip-execution"]
 git bisect bad
