I think my favourite part is the fact that '1' isn't even one of the supported values.

But that's because my wife requests it.

It would never occur to me to up the egg ratio so high to reach into that void though. My wife manages to mess up the proportions every time though, so maybe we'll unwittingly explore that region one day.

But my point is, is that I believe the important thing to preserve in history is whatever your unit of review is. If you could stack PRs and each were subject to the individual review, I would not combine and squash those (just the individual commits within each PR).

This constraint is usually enforced by code review.

On Github, the unit of code review is the PR.

Therefore, I prefer squashing.

Please consider a variable `List{int}[3] x`, this is an array of 3 List{int} containing List{int}. If we do `x[1]` we will get an element of List{int}, from the middle element in the array. If we then further index this with [5], like `x[1][5]` we will get the 5th element of that list.

I get that motivation. In C++ it's an odd case that where `std::vector x[4]` is "reversed" in a sense compared to `int x[4][100]`. And this quirk is shared with other languages (Java, C#).

But in my experience, mixing generic datatypes like this with arrays is quite rare, and multi-dimensional array like structures with these types is often specified via nesting (`std::vector>`) which avoids confusion.

The argument re. pointers is more convincing though.

It would require more thinking on my end to change that to either 'this is an acceptable choice' or 'this is a terrible idea'.

But the array indices being reversed on declaration? I cannot think of an upside to that at all.

https://c3-lang.org/language-common/arrays/#fixed-size-multi...

Multi dimensional arrays are not declared in the same way they are accessed; the order of dimensions is reversed.

Accessing the multi-dimensional fixed array has inverted array index order to when the array was declared.

That is, the last element of 'int[3][10] x = {...}' is accessed with 'x[9][2]'.

This seems bizarre to me. What am I missing? Are there other languages that do this?

End of life care* is highly variable in duration and costs and many people do not adequately prepare for expensive endings.

* this is true of more than just care post retirement

Decline like this is difficult to reverse, but that doesn't mean we shouldn't try.

The overall project history though, the clarity of changes made, and that bisecting reliably works are important to me.

Or another way; the important unit is whatever your unit of code review is. If you're not reviewing and checking individual commits, they're just noise in the history; the commit messages are not clear and I cannot reliably bisect on them (since nobody is checking that things build).

But maybe it does all just come down to equality comparisons. Just not always within your own code.

I don't often care about a specific order, only that I get the same order every time.

But there are definitely companies that use Bazel in a major way.

I believe only the US has a strong distinction between Prison and Jail.

My own interpretation is that it's difficult to precisely compare how peasants were exploited to modern taxation regimes in the developed world. Perhaps more as an unfavorable relationship with the only employer in town?

So torso hits from behind are the way to go.

A microcentury is 100 nanoyears if you prefer that.

They're just a tad more verbose in Python than mathematics because it uses words like 'for' and 'in' instead of symbols.