_ikke_

The branch reflog (git reflog <branchname> or git log -g <branchname>) is a lot easier to follow in the case of rebase than the HEAD reflog (which gets an entry for each commit that gets checked out / applied).

My favorite from this release.

> The built-in new function, which creates a new variable, now allows its operand to be an expression, specifying the initial value of the variable.

So no need for separate helpers anymore to instantiate a pointer to a literal.

As long as what it says is reliable and not made up.

That's why I mentioned multiple addresses. The public addresses (assigned using SLAAC or DHCPv6) are for global reachability, while you use the local prefix for stable addresses within your network.

If you want stable global addresses, you should request an AS number and prefix, and choose a provider that allows you to announce it with BGP.

The ipv4 routing table contains many individual /24 subnets that cannot be summarized, causing bloat in the routing tables.

With ipv6, that can be simplified with just a couple of /32 or /48 prefixes per AS.

With IPv6, it's common to have multiple addresses on an interface.

So on options is to assign yourself an [RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193) fc00::/7 random prefix that you use for local routing that is stable, while the ISP prefix can be used for global routing.

Then you don't need to renumber your local network regardless of what your ISP does.

Instead, you get to hunt the nouns.

It affects many open source projects as well, they just scrape everything repeatedly without abandon.

First from known networks, then from residential IPs. First with dumb http clients, now with full blown headless chrome browsers.

Only if that AI does not hallucinate, otherwise it would be useless.

Systems that use shamirs secret sharing, like openbao, require multiple operators to unlock the secret engine.

Gitlab premium can also require multiple approvals before a merge request can be merged.

If a TUI is an option, then `tig blame` is a good interface.

https://github.com/jonas/tig

> OpenSSH sshd on musl-based systems is not vulnerable to RCE via CVE-2024-6387 (regreSSHion).

https://fosstodon.org/@musl/112711796005712271

They have a blogpost about it: https://tailscale.com/blog/free-plan

> TL;DR: Tailscale’s free plan is free because we keep our scaling costs low relative to typical SaaS companies. We care about privacy, so unlike some other freemium models, you and your data are not the product. Rather, increased word-of-mouth from free plans sells the more valuable corporate plans. I know, it sounds too good to be true. Let’s see some details.

Until you want to introduce a change that affects both machines. You need to start rewriting history or cherry-pick the changes on both branches. The further the history diverges, the harder this becomes.

Using branches for this does not scale.

It's surprising how often projects retag releases. Diffoscope makes it easy to see the difference between the original tarball and the retagged versions.

Changes vary from from forgetting to update an in-source version to tagging the wrong commit to fixing file metadata (file owner in the tarball).

For someone who understands git, it certainly is not. But if you are not aware of how git works, committing things when HEAD is detached could to confusion in the best case, and lost commits in the worst.

git diff by default outputs valid patch files that you can feed to patch out git apply.

--word-diff does not

Kernel development involves working with patches a lot, so it made sense to default to that, and --word-diff was added later anyway.

Lift-off

Which is the equivalent of a fast-forward merge. Same result, different mechanism.

Lots of criss-cross merges make it really difficult to follow history, making it less useful.

Note that merge vs rebase a false dichotomy. After rebasing you still have to merge your branch anyway, either fast-forward or with an explicit merge commit.

In the end, it's about commutating your changes effectively. The less noise there is, the better you can communicate. That takes effort from both sides, but many persons put all the burden on the receiving side.

> Tools have been written to identify these mistakes, but it is hard to analyze whether references to a variable outlive its iteration or not. These tools must choose between false negatives and false positives. The loopclosure analyzer used by go vet and gopls opts for false negatives, only reporting when it is sure there is a problem but missing others.

So it will warn in certain situations, but not all of them

The smallest prefix that can be routed is a /24, so that's the minimum amount you can get.

No, that's just copyright infringement. You use the license as a contract in order to use the code without infringing on copyright.

If you don't adhere to the conditions in the license, the license is revoked, and you're back to copyright infringement, with all the consequences.

It stops and asks you to resolve it and then you'd use the regular git commands to continue that operation (like git rebase --continue)