main branches locally

Posted Oct 23, 2025 19:00 UTC (Thu) by mathstuf (subscriber, #69389)
In reply to: main branches locally by Wol
Parent article: Git considers SHA-256, Rust, LLMs, and more

Yeah, I'm in agreement with Wol here. A single branch on the fork to serve as a "baseline" is useful. Forges could have an option to sync it automatically (a button, automatic, or scheduled), but having it not-exist introduces questions of what it means when your last feature branch is merged and you delete it. Is the `HEAD` ref resynced to keep the repository alive? I'm just glad the option is there because I never liked forking causing content to be hosted under my handle (copying the `gh-pages` branch).

*My* pet peeve is using the upstream repository for any feature branches at all. Forges have finally gotten a clue and offered the "only copy the `HEAD` ref" trick, but I'd really rather *everyone* use their own fork for development (at least for projects with any kind of velocity…I have far more leeway for personal projects where cleanup was a feature branch or two a week). But fetching from GitLab's `origin` repository and having 100s of refs to update, prune, and manage is insane.

to post comments

main branches locally

Posted Oct 23, 2025 19:06 UTC (Thu) by josh (subscriber, #17465) [Link] (4 responses)

> A single branch on the fork to serve as a "baseline" is useful.

But it *isn't* a baseline. Assuming I don't screw up and push to main by accident, all it does is provide a stale years-old snapshot of the upstream project's main branch (including its README), unrelated to any actual development going on in the repository.

> but having it not-exist introduces questions of what it means when your last feature branch is merged and you delete it. Is the `HEAD` ref resynced to keep the repository alive?

There's no fundamental reason a repository *couldn't* be kept alive with a virtual/fake/nonexistent HEAD. And to the extent forges don't support that, I'm frankly tempted sometimes to push a main branch containing a single empty commit, and make that HEAD. That's all independent of the metadata forges have showing what repository it was forked from.

main branches locally

Posted Oct 24, 2025 1:38 UTC (Fri) by mathstuf (subscriber, #69389) [Link] (3 responses)

That was the point of the following sentence:

> Forges could have an option to sync it automatically (a button, automatic, or scheduled),

I agree that it is annoying that it is not (often) synchronized. I typically only do so to make it easier to batch-delete already-merged branches on the remote (`git branch -a --merged` exists, but it is useful to have the "how far ahead/behind" view).

> There's no fundamental reason a repository *couldn't* be kept alive with a virtual/fake/nonexistent HEAD.

I guess my question is: what happens when you fetch from your fork in this state?

Forges do store repositories in a single object space and namespaced refs. I wonder if a symref can point between namespaces so that your fork's main is just a symref to the origin's main.

main branches locally

Posted Oct 24, 2025 23:26 UTC (Fri) by intgr (subscriber, #39733) [Link] (2 responses)

> I agree that it is annoying that [main branch] is not (often) synchronized

But why spend the compute resources updating the branch if users don't need or use it? Even if it were periodically updated, that would just create the illusion of an up to date branch. When I rebase, I want the latest origin/main, not "a few hours out of sync" one.

I might only use the fork for one pull request and never thereafter. Why even waste the disk space if there are no remaining feature branches?

As for "baseline state" of the fork: that's just the common ancestor of upstream repo and any particular feature branch.

I had never thought about these things but everything that gioele and Josh here said is a revelation about why git and the forges based on it feel so clunky to interact with.

main branches locally

Posted Oct 25, 2025 2:01 UTC (Sat) by mathstuf (subscriber, #69389) [Link] (1 responses)

> When I rebase, I want the latest origin/main, not "a few hours out of sync" one.

That's fine; why is your local `main` tracking your fork's `main` if you're not keep it up-to-date?

> I might only use the fork for one pull request and never thereafter. Why even waste the disk space if there are no remaining feature branches?

Forks live in the same repository as the main one. They are segregated using git namespaces (see `gitnamespaces(7)`) so that each access uses a different ref namespace and cannot "see" each other. This is the root cause of that issue where one could push a commit to a fork and then rewrite the URL to be that of the main repository and it would render your content under upstream's URL. I believe there is now a banner when this is done to show that the content is not actually "in" the repository being viewed when the object/tree/commit is not actually reachable from the project's ref namespace.

There was slight reference to this in it being "20 bytes on disk" elsewhere in this thread, but even that might be wrong (besides ref files being 40 bytes due to their ASCII representation) because I believe forges now use `reftable` to store refs in a single file (sqlite db?) rather than a file-per-ref due to filesystem overhead with that mechanism. The vast majority of the cost of a fork is in the database presence it takes up, not the git repository itself.

The shared-repository-with-namespaced-refs is also why I think some namespace-hopping symref to just make a fork's `main` *be* upstream's `main` would be an ideal solution here.

main branches locally

Posted Oct 25, 2025 3:03 UTC (Sat) by josh (subscriber, #17465) [Link]

> Forks live in the same repository as the main one. They are segregated using git namespaces (see `gitnamespaces(7)`) so that each access uses a different ref namespace and cannot "see" each other.

14 years ago, a friend and I wrote the first version of the git namespaces support. :)

This is very much what I had in mind when saying that there's no fundamental reason a fork "needs" a main branch, or a distinct main branch, in order to be tied to the original repository.

> I had never thought about these things but everything that gioele and Josh here said is a revelation about why git and the forges based on it feel so clunky to interact with.

❤️

main branches locally

Posted Oct 23, 2025 21:00 UTC (Thu) by gioele (subscriber, #61675) [Link] (3 responses)

> *My* pet peeve is using the upstream repository for any feature branches at all. Forges have finally gotten a clue and offered the "only copy the `HEAD` ref" trick, […]

Some forges even have an "update fork" button/API as well as ways to periodically fetch updates the the HEAD-pointed branch.

I'd love if git-the-command-line-tool could also finally get a clue about this paradigm.

I'd like to be able to do something like `git clone $MYFORK-REPO-ON-A-FORGE --real-upstream $UPSTREAM-REPO` and have git taking care of:

1) correctly setting the remote from which branches should be pushed and pulled (`main` should be merged ff-only from $UPSTREAM-REPO, but pushed to $MYFORK-REPO-ON-A-FORGE),
2) ignore all branches of $UPSTREAM-REPO not pointed by HEAD (so, only fetch `main`),
3) prevent direct pushes to $UPSTREAM-REPO (I may have admin access to that repo, but our workflow is PR-based),
4) block commits to the `main` branch (all development should happen in feature branches).

I know that there are plenty of situations in which this kind of arrangement would not work, but it would cover the vast majority (95%+) of the projects and repos I deal with.

main branches locally

Posted Oct 24, 2025 1:44 UTC (Fri) by mathstuf (subscriber, #69389) [Link] (2 responses)

> 1) correctly setting the remote from which branches should be pushed and pulled (`main` should be merged ff-only from $UPSTREAM-REPO, but pushed to $MYFORK-REPO-ON-A-FORGE),

If upstream ever rewrites history, the `ff-only` can leave you stranded. I prefer to just always trust what the remote repo is. Granted, actual rewriting should be for *extreme* cases (e.g., legal in nature or catastrophic like "oops, committed my VM disk"), but I see no reason to force ff-only here.

> 2) ignore all branches of $UPSTREAM-REPO not pointed by HEAD (so, only fetch `main`),

Some projects have support branches (`release` or the like). I also like to have these. It's the main reason I prefer upstream repos to only publish their maintained branches.

> 3) prevent direct pushes to $UPSTREAM-REPO (I may have admin access to that repo, but our workflow is PR-based),
> 4) block commits to the `main` branch (all development should happen in feature branches).

Branch protection rules (i.e., server-side git hooks) should handle these situations. There's nothing to be done on the developer's side for these as I want the server to enforce them.

> I know that there are plenty of situations in which this kind of arrangement would not work, but it would cover the vast majority (95%+) of the projects and repos I deal with.

Yes, but when you bake in policy, all those corner cases become much sharper. Personally, I have a `git gh-add-fork` command that adds a fork on github to a repo I have with a structured name (`gh/$handle`) and, if it is my handle, sets it as the `remote.pushdefault` as well.

main branches locally

Posted Oct 24, 2025 10:00 UTC (Fri) by gioele (subscriber, #61675) [Link] (1 responses)

> > 1) correctly setting the remote from which branches should be pushed and pulled (`main` should be merged ff-only from $UPSTREAM-REPO, but pushed to $MYFORK-REPO-ON-A-FORGE),
>
> If upstream ever rewrites history, the `ff-only` can leave you stranded. I prefer to just always trust what the remote repo is.

Agreed. What I meant was "ff-only" by default. If a pull cannot be fast-forwarded then I definitely want to know about it. I will mostly likely pass some option that says "it's OK, overwrite the branch instead of merging it", but I want to be in control of that.

> > 3) prevent direct pushes to $UPSTREAM-REPO (I may have admin access to that repo, but our workflow is PR-based),
> > 4) block commits to the `main` branch (all development should happen in feature branches).
>
> Branch protection rules (i.e., server-side git hooks) should handle these situations. There's nothing to be done on the developer's side for these as I want the server to enforce them.

As an admin I should have the ability to push whatever I want (or need) to any branch. But that's a big gun pointing at my foot, so I'd like my local tools to not allowing me to do that by default and then shout loudly when I ask them to do it nevertheless. Server-side hooks can be used to implements something similar, but IMO they should be used to solve problems like enforcing policy and access control, rather than as preventive measures for common mistakes.

main branches locally

Posted Oct 24, 2025 13:33 UTC (Fri) by mathstuf (subscriber, #69389) [Link]

> As an admin I should have the ability to push whatever I want (or need) to any branch. But that's a big gun pointing at my foot, so I'd like my local tools to not allowing me to do that by default and then shout loudly when I ask them to do it nevertheless. Server-side hooks can be used to implements something similar, but IMO they should be used to solve problems like enforcing policy and access control, rather than as preventive measures for common mistakes.

Sure, the *ability* makes sense, but I'd rather have to go back to the forge, open the gate, do the action, then close the gate again. Having admin privileges just "laying around" is not a good idea (as you need to keep this in mind when onboarding new co-admins) and as an additional layer of defense in case your machine/key becomes compromised (not limited to rogue LLM-based agents "trying to help" or trying to cover their own mistakes).

I also can't say I've seen "common" mistakes which require rights to rewrite history (e.g., any token leak is not a reason as once it is leaked, it needs rotated anyways, so there's no reason to scrub it from history either). I acknowledge they can exist…but I'd also rather continue doing the "gate" thing to help try and train those making the mistakes to, maybe, not do that?