As a fellow rebase enjoyer, I will do it occasionally for smaller PRs but to me, it becomes unwieldy for large ones.

Do you have any tips or aliases that makes it more workable?

Right now there are effectively three ways to do a PR:

- a bunch of small commits, some of them related to the feature, some fixes, some mixing both -> a PR with 'n' commits -> they don't really make sense as atomic commits, you have to review the entire PR to make the sense of it

- a squashed PR

- some uber principled reorganisation of commits that separates key implementation concerns into smaller commits (effectively stacked PRs but clean)

The last option would be desirable but it's unreasonable to expect anyone to do it by hand. So this is where an LLM could parse my garbage intermediate commits, the final diff and generate a stack instead?

Sure, we can follow the advice of creating types that represent only valid states but then we end up with `fn(a: A, b: B, c: C) transformed into `fn(abc: ValidABC)`

You’re perpetuating a gross misunderstanding of the cookie law. What it states is different from how the advertisers implement malicious compliance to bias people, like yourself.

Websites that implement basic functional cookies do not need to display any popups. They’re permitted to do so. Any cookies that are essential to the functioning of the website within reason are permitted. In fact at no point a website should serve you a cookie popup unless you seek it out because analytics and advertising cookies are supposed to be opt in.

So many websites do two things, serve you a popup that has everything enabled which is a clear violation; or a popup that has only functional cookies selected but the biggest highlighted button allows all of them.

The law is fine. Malicious compliance is to blame. The EU has been slow to rectify it.

- C "standard" is quite flaky in practice, there are lots of un/underdefined things that compilers interpret quite liberally for the purpose of optimisations

- complaining about the syntax and symbols is unfair: rust offers all these semantics to represent the memory model of your codebase. The equivalent is not possible in C/C++, and when we try to do it, we're inventing our own constructs at the code level instead of relying on the syntax

A second hand DSLR setup is going to be roughly the same price or less. I'm also not sure what kind of workflow improvements it actually offers. If you want fancy and experimental, filmomat has arguably a more interesting but pricier offering.

But naysaying aside, I hope they manage to find a niche that allows them to survive as a company, and keep the analog photography revival alive.

A notable example was passing around an implicit ExecutionContext for thread pools, e.g. in Akka :)

At its core, the core issue seems to be the lack of accountability between the MEP, and people that voted them in. Few people vote in the EU elections, and even fewer follow up on what happens there.

Chicken and egg problem but if you want your MEP not to be just "a good obedient MEP they are", the electorate needs to ask more of them.

1. My company cannot justify this cost at all.

2. My company can justify this cost but I don't find it useful.

3. My company can justify this cost, and I find it useful.

4. I find it useful, and I can justify the cost for personal use.

5. I find it useful, and I cannot justify the cost for personal use.

That aside -- 200/day/dev for a "nice to have service that sometimes makes my work slightly faster" is much in the majority of the world.

I find LLM-based tools helpful, and use them quite regularly but not 20 bucks+, let alone 100+ per month that claude code would require to be used effectively.

But I just can't go back to their predatory pricing practices, and the absolute malware of a programme that creative cloud is.

As other commenters pointed out this is "just" a signature. However, in the absence of standardised checks, this is a useful intermediate way of addressing the integrity issue around ML supply chain; FWIW today.

Eventually, you want to move to more complete solutions that have more elaborate checks, e.g. provenance of data that went into the model, attested training. C2PA is trying to cover it.

Inference time attestation (which some other commenters are pointing out) -- how can I verify that the response Y actually came from model F, on my data X, Y=F(X) -- is a strongly related but orthogonal problem.