I’ve been using git to keep revisions of my website. Since I work alone I only need three commands:

git add -A
git commit -m “<description>”
git push

Soon I’ll be adding a second person, and I remember from experience that conflicts can happen even with two people. So I have two questions:

• Is there a way we can avoid that happening outright?
• Are the commands to resolve fairly standard or does it differ much on a case-by-case basis? I’m hoping to keep the number of commands as small as possible.

Have any of you tried out fossil as an alternative to git? I have been using it for about a week, and I think I am in love. I have used git for years, since having some sort of source control is absolutely essential in programming. But I never liked git or felt comfortable using it. Within a week of messing with fossil, I feel like I understand it and can use it without a guide or external tools. It also has an issue tracker, forums, and a wiki built in.

Fossil Versus Git

I recommend reading all of that, especially section 2.5. Their description of cathedral style development lines up much more closely to everything I have worked on than git's bazaar style. Another thing I love is the ability to have the same repo open in multiple different folders at the same time. Basically everything about fossil lines up much more closely with what I think a source control program should be, at least for my use.

I cannot push nor pull to/from my local repo to/from my remote. I get the message "Your branch and 'origin/main' have diverged", etc.

I will be able to fix it, I'm already in the process of refreshing my memory on how to rebase this cleanly.

But ... I am the only person working on this. I have only one local and one central/remote repository. And I never made a branch.

It's just me, working on one computer, right here ... make a few commits locally, then push 'em ... make a few commits locally, then push 'em. That is my entire workflow.

How in the hell did I end up with "my branch" (???) and the origin/main branch being in conflict with each other?

Any Git gurus care to take a stab at this?

Thanks in advance.

Edit, more info:

I am guessing here, but for awhile I was working in a VM on my local machine ... but Android SDK is too much of a resource hog, so I committed and pushed everything on the VM, shut it down, and then pulled latest down to my actual machine ... or at least, that's how I remember it.

My working theory is that, somehow, I screwed up that "switching between machines" process, although, so far, no clue as to how/why I did.

Theory #2 is that Android SDK did something sneaky/stupid behind the scenes -- my last several commits have been done through the Android Studio IDE, not directly in the terminal.

Last Edit:

D'oh!

Found it. I made a couple of "quick changes" to the project's README.md file directly in the remote forge, and that's what screwed me up.

Pretty much, the title.

I have been coding professionally for over 2 decades, been using Git for almost as long ... and to this day, it still feels alien and uncomfortable to use. I keep feeling like I am relearning it all over again. I would really like to find some kind of different resource that helps me to make Git "stick" in my brain, and become more intuitive. Maybe that's just not possible, but I keep hoping.

Meanwhile, my roommate is just starting her journey into programming, and her class just started teaching Git ... and I'm eavesdropping a bit, and they're teaching it okay, but I'm sure there are better tutorials out there for a newcomer.

I am aware of -- and currently reading my way through -- both this recent tildes post and the various tutorials mentioned in it. But I am looking for other recommendations, as well ... and I bet I'm not the only one.

Thanx in advance.

I struggled to word this question.

Let's say that I wish to work on a project to benefit Tildes (I don't currently have an idea, but just for example). Anything I did, I would like to keep opensource and would encourage other users to contribute. But I would like to keep everything linked to my pseudonym as not to dox myself.

However, I would like to have a copy of everything on my personal GitHub as well, because I am a professional programmer and that is effectively my CV.

Is there a good way to mirror a repo in a way that any git history contributed by me, "John Smith", is changed to "bugsmith" on the mirrored repo? (or vice versa).

And no, I'm not talking about git. I'm looking for a tool that I can use in scripts to automate non-git tasks on GitHub such as creating new repositories, drafting releases, uploading assets to a release, etc.

I started dipping my toes into gh, GitHub's official cli tool, but when I created a repository it immediately cloned it, which is not what I want. I know I can just rm -rf the repo but ideally the tool I use would do only what I tell it and nothing more.

Reading the docs for hub, it might do what I want, although I have some reservations about the project after reading this post written by the developer: https://mislav.net/2020/01/github-cli/

I've also come across git-hub, which doesn't support creating repos AFAICT, and git-spindle, which doesn't support uploading assets.

Are there any other command line GitHub clients I should consider?

Which one do you use? What's your experience with it been like?

Some of my favorites are:

git add -p *

This will go through your unstaged changes in chunks and allow you to stage each chunk individually in an interactive shell.

git checkout -p *

Similar to the above, this will go through your unstaged changes and allow you to undo each chunk. I almost never use Ctrl+Z anymore and go straight for this. Want to remove all of those print-debugging statements? Use this command to pluck them out one-by-one.

git commit -a --amend --no-edit && git push --force-with-lease

I alias this one to whoops in my bash profile. It will add all unstaged changes, add them to your last commit and then (safely) force-push the local branch to the tracked remote branch. This is especially useful when working with CI and you need to make constant configuration changes to get it to work. Yes, you could squash those commits afterwards as an alternative. But this is easier.

git rebase -i HEAD~5

(Change 5 to the number of previous commits you want to see)

Interactive rebases are a core part of my git flow when working on feature branches. If a co-worker gives me feedback on a code review that requires a change to a previous commit I'll go back and edit that commit using this command. You can remove individual commits, squash commits, reorder commits, and so much more.

I was fed up with the chores of writing consistent git commit messages, so a while ago I started developing a hook in Emacs which I used with Magit (actually git-commit-mode) which uses some crude heuristics to fill out the COMMIT_EDITMSG buffer for me. Here is what it does (| stands for the cursor):

• If only a single file modified, insert <filename>: |

  • If can figure out function name, insert <filename> (<functionname>): |

• If only a single file added, insert Add <filename>|

• If a TODO added to Readme.org, insert ; TODO <headline>|

• If a TODO was DONE, insert ; DONE <headline>|

• If the files are Readme.org and Readme.org_archive, and no new TODO's were added anywhere, insert ; Archive DONE|

• If the file is .gitignore, insert ; Ignore |

• If the file is TAGS, insert ; Update TAGS|

I extend this when I find new cases where I repeatedly do the same thing. The code is below. It's probably a good idea to use it as a starting point and personalise it because this reflects how I like to write my commit messages (and I like pretending how they do it over at Emacs git repo). It is sloppy and probably buggy, but I don't think it can be destructive.

Final note: I can't figure out how to set this up so that after this takes effect, the buffer is marked as modified. I want to flip the modified bit so that in some cases I can just hit C-c C-c and go. But I need to modify the buffer somehow to commit in some cases (I just type C-o to open a new line in those cases). Here is the function:

(defun gk-git-commit-mode-hook ()
  "Set up git commit buffer."
  ;; If a single file is modified, prefix the message w/ it.
  (let ((modified-re "^#	modified:")
        (new-re "^#	new file:")
        (issue-re "^[+\\- ]\\*+ \\(TODO\\|DONE\\) ")
        current-defun filename addp onlyp issuep)
    (save-excursion
      (with-current-buffer "COMMIT_EDITMSG"
        (goto-char (point-min))
        (re-search-forward "^# Changes to be committed:" nil t)
        (forward-line)
        (beginning-of-line)
        (cond ((looking-at modified-re)
               (re-search-forward ":   " nil t)
               (setf filename (thing-at-point 'filename t)))
              ((looking-at new-re)
               (re-search-forward ":   " nil t)
               (setf filename (thing-at-point 'filename t)
                     addp t)))
        (setq onlyp (progn
                      (forward-line)
                      (not (or (looking-at modified-re)
                               (looking-at new-re)))))
        (when (and onlyp (equal filename "Readme.org"))
          (goto-char (point-min))
          (when-let* ((pos (re-search-forward issue-re nil t)))
            (setq issuep (progn
                           (re-search-backward "\\*" nil t)
                           (buffer-substring (1+ (point))
                                             (line-end-position))))))
        ;; Try to set ‘current-defun’.
        (when onlyp
          (save-excursion
            (goto-char (point-min))
            ;; Error if not found, means verbose diffs
            ;; not enabled.
            (re-search-forward "^diff --git")
            (goto-char (line-beginning-position))
            (let ((str (buffer-substring (point) (point-max)))
                  (default-directory (expand-file-name "..")))
              (with-temp-buffer
                (insert str)
                (diff-mode)
                (goto-char (point-min))
                (setq current-defun (diff-current-defun))))))))
    (if onlyp
        (cond
         ((and issuep (not addp))
          (goto-char (point-min))
          (insert ";" issuep))
         ((equal filename "TAGS")
          (goto-char (point-min))
          (insert "; Update TAGS"))
         ((equal filename ".gitignore")
          (goto-char (point-min))
          (insert "; Ignore "))
         (filename
          (goto-char (point-min))
          (if addp
              (insert "Add " filename)
            (insert
             filename
             (if (and current-defun)
                 (format " (%s)" current-defun)
               "")
             ": "))))
      (when (and (equal filename "Readme.org")
                 (save-excursion
                   (goto-char (point-min))
                   (re-search-forward (concat modified-re " +Readme.org_archive")
                                      nil t))
                 (save-excursion
                   (goto-char (point-min))
                   (re-search-forward "\\-\\*+ DONE" nil t))
                 (not
                  (save-excursion
                    (goto-char (point-min))
                    (re-search-forward "\\+\\*[\\+\\-] TODO" nil t))))
        (goto-char (point-min))
        (insert "; Archive DONE")))))

(add-hook 'git-commit-mode-hook #'gk-git-commit-mode-hook)

Hope you find it useful.

Okay, I know the obvious answer is the history of the files. But how can I, from the command line, really understand what is hiding inside that .git directory?

Today I was doing one of my periodic disk space audits, trying to figure out where my usage goes. This comes from having a 64GB drive mounted as /home on my Linux laptop. I found some 15G of old video files to delete today, so I'm no longer as pressed for space. But my interest was piqued by one thing I have downloaded from Github that is ~120 megs for a very simple program. Poking around further I find that most of that usage is a single file:

$ ls -lh withExEditorHost/.git/objects/pack/pack-df07816cd15fb091439112029c28ebc366501652.pack
-r--r--r-- 1 elijah elijah 102M Mar 14 23:28 withExEditorHost/.git/objects/pack/pack-df07816cd15fb091439112029c28ebc366501652.pack
$ file withExEditorHost/.git/objects/pack/pack-df07816cd15fb091439112029c28ebc366501652.pack
withExEditorHost/.git/objects/pack/pack-df07816cd15fb091439112029c28ebc366501652.pack: Git pack, version 2, 299 objects
$

Is there a unzip or tar xzf equivalent for Git pack files? Naive usage of git unpack-file is only generating errors for me.

I have an idea, it's not particularly new. I think git code sharing could integrate very nicely with blockchains.

I think it could be done elegantly without modifying the git protocol at all, just as an optional superset (like Github) to provide forks, PR and discussion.

Something like:

• smart contract based system
• something like lightening network for off master chain pushes
• local node hosting all obtained versions of code, something like PNPM meets zeronet
• cloning/pushing over DHT with web torrent.
• client key pairs for collaboration and authentication

Do you guys think it could be done? Thoughts? Ideas? Criticisms?

Would anyone be interested in working on something like this? I'd like all the help I can get and any input people have.