los-opinionated-git-tools VS Git

A bunch of shell scripts I've written over the years are available from https://git.marcofontani.it/mfontani/scripts

Very useful ones:

- evenodd, to colorize the background of lines of text so it's easier to see which start of text corresponds to which end of text

- time-rollup, to time the time it takes to run a given command and provide percentage-based statistics on the execution

- a wrapper around "jq" to make it DWIM w/regards to gzipped, bzipped, and zstd-compressed files

I've also put some full-fledged binaries on github:

- https://github.com/mfontani/prettycrontab which is a crontab pretty-printer which parses a possibly specially commented crontab to give you an overview of what's coming up next

- https://github.com/mfontani/tstdin to timestamp your stdin, and provide when the line was received, how long it was since the start of the command, and how long it was since the last line was received. Useful to add at the end of a pipe to both log and perform analysis on the output and time it took to do stuff

- https://github.com/mfontani/rofixec to "sorta template" a rofi (a X11 runner) runner so it picks commands from a given list (provided as yaml or json configuration) and executes the picked item in a background job

- https://github.com/mfontani/git-recent which helps you pick the most recent branches you've worked on, very useful when paired with fzf for picking

- https://github.com/mfontani/los-opinionated-git-tools instead contains a ton of useful little git-related scripts, from one which DWIMs the master/main/blead branch name to one which helps you reauthor the last commit, to one (git-rr) which helps you perform a git rebase with context info about the commits you're rebasing: which files they touched, etc - to make it easier to fixup together commits which touched the same file... which is an operation I do so often I've created a "git-fixup" script, which automates fixing up the currently committed file to the last commit which touched that file in the branch

I've had to deal with projects where the "main" branch was named: master, main, blead.

I almost never "name" that "main" branch, thanks to commands and aliases.

When I want to pull (and rebase) to the "main" branch, I run "git prom". When I want to check out the "main" branch, I "git com". What actually happens depends on what the project's "main" branch is. If a project later moves to a "live" branch, I'll just update the "git-main" script to detect it ahead of the rest, and off I go.

https://github.com/mfontani/los-opinionated-git-tools/blob/m... is less than ten lines of bash.

git-com is really just: git checkout "$(git main)"

git-prom is really just: git pull --rebase origin "$(git main)"

I'm not particularly sold on "main" vs "master" being an important thing, but if it's important to some I at least want to ensure I don't get frustrated when interacting with a project which uses it. With the above aliases and functions and programs, I don't care anymore.

main, master, blead... call it whatever.

Look at any PR/patch series that got merged into the Git project. https://github.com/git/git/

Any random one. Because those that did not meet the minimum criteria for a well-crafted history would not have passed review.

Boy, I can't find this either (but also, the kernel mailing list is _really_ difficult to search). I really remember Linus saying something like "it's not a real SCM, but maybe someone could build one on top of it someday" or something like that, but I cannot figure out how to find that.

You _can_ see, though, that in his first README, he refers to what he's building as not a "real SCM":

https://github.com/git/git/commit/e83c5163316f89bfbde7d9ab23...

Here is the direct link, as HN somehow removes the query string: https://github.com/git/git/commits?author=peff&since=2023-10...

I understand all that.

I'm saying, if you write a survey and one of the possible answers is "diff", but you don't clearly define what you mean by "diff", then don't be surprised if respondents use any reasonable definition that makes sense to them. Ask an ambiguous question, get a mishmash of answers.

The thing that Git uses for packfiles is called a "delta" by Git, but it's also reasonable to call it a "diff". After all, Git's delta algorithm is "greatly inspired by parts of LibXDiff from Davide Libenzi"[1]. Not LibXDelta but LibXDiff.

Yes, how Git stores blobs (using deltas) is orthogonal to how Git uses blobs. But while that orthogonality is useful for reasoning about Git, it's not wrong to think of a commit as the totality of what Git does, including that optimization. (Some people, when learning Git, stumble over the way it's described as storing full copies, think it's wasteful. For them to wrap their heads around Git, they have to understand that the optimization exists. Which makes sense because Git probably wouldn't be practical if it lacked that optimization.)

The reason I'm bringing all this up is, if you're trying to explain Git, which is what the original article is about, then it's very important to keep in mind that someone who is learning Git needs to know what you mean when you say "diff". Most people who already know Git would tend to gravitate toward the definition of "diff" that you're assuming (the thing that Git computes on the fly and never stores), but people who already know Git aren't the target audience when you're teaching Git.

---

[1] https://github.com/git/git/blob/master/diff-delta.c